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

Merge branch 'new-json-parser' into develop

Browse Source
This commit is contained in:
emeric
2023-10-22 13:36:10 +02:00
parent 4562e0368a 43131d391e
commit 3920c36896
27 changed files with 655 additions and 526 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/libs/services/database/impl/Cluster.cpp
+3 -3
View File
@@ -32,11 +32,11 @@ namespace Database
{ {
namespace namespace
{ {
Wt::Dbo::Query<ClusterId> createQuery(Session& session, const Cluster::FindParameters& params) Wt::Dbo::Query<Cluster::ClusterFindResult> createQuery(Session& session, const Cluster::FindParameters& params)
{ {
session.checkSharedLocked(); session.checkSharedLocked();
auto query{ session.getDboSession().query<ClusterId>("SELECT DISTINCT c.id FROM cluster c") }; auto query{ session.getDboSession().query<Cluster::ClusterFindResult>("SELECT DISTINCT c.id,c.name FROM cluster c") };
if (params.track.isValid() || params.release.isValid()) if (params.track.isValid() || params.release.isValid())
{ {
@@ -74,7 +74,7 @@ namespace Database
return session.getDboSession().query<int>("SELECT COUNT(*) FROM cluster"); return session.getDboSession().query<int>("SELECT COUNT(*) FROM cluster");
} }
RangeResults<ClusterId> Cluster::find(Session& session, const FindParameters& params) RangeResults<Cluster::ClusterFindResult> Cluster::find(Session& session, const FindParameters& params)
{ {
session.checkSharedLocked(); session.checkSharedLocked();
auto query{ createQuery(session, params) }; auto query{ createQuery(session, params) };
src/libs/services/database/impl/Db.cpp
+64 -43
View File
@@ -26,73 +26,94 @@
#include "services/database/User.hpp" #include "services/database/User.hpp"
#include "utils/Logger.hpp" #include "utils/Logger.hpp"
namespace Database { namespace Database
// Session living class handling the database and the login
Db::Db(const std::filesystem::path& dbPath, std::size_t connectionCount)
{ {
namespace
{
class Connection : public Wt::Dbo::backend::Sqlite3
{
public:
Connection(const std::filesystem::path& dbPath)
: Wt::Dbo::backend::Sqlite3{ dbPath.string() }
, _dbPath{ dbPath }
{
prepare();
}
private:
Connection(const Connection&) = delete;
Connection& operator=(const Connection&) = delete;
std::unique_ptr<SqlConnection> clone() const override
{
return std::make_unique<Connection>(_dbPath);
}
void prepare()
{
LMS_LOG(DB, DEBUG) << "Setting per-connection settings...";
executeSql("pragma journal_mode=WAL");
executeSql("pragma synchronous=normal");
executeSql("pragma analysis_limit=1000"); // to help make analyze command faster
LMS_LOG(DB, DEBUG) << "Setting per-connection settings done!";
}
std::filesystem::path _dbPath;
};
}
// Session living class handling the database and the login
Db::Db(const std::filesystem::path& dbPath, std::size_t connectionCount)
{
LMS_LOG(DB, INFO) << "Creating connection pool on file " << dbPath.string(); LMS_LOG(DB, INFO) << "Creating connection pool on file " << dbPath.string();
std::unique_ptr<Wt::Dbo::backend::Sqlite3> connection {std::make_unique<Wt::Dbo::backend::Sqlite3>(dbPath.string())}; auto connection{ std::make_unique<Connection>(dbPath.string()) };
// connection->setProperty("show-queries", "true"); // connection->setProperty("show-queries", "true");
connection->executeSql("pragma journal_mode=WAL");
connection->executeSql("pragma synchronous=normal");
auto connectionPool = std::make_unique<Wt::Dbo::FixedSqlConnectionPool>(std::move(connection), connectionCount); auto connectionPool{ std::make_unique<Wt::Dbo::FixedSqlConnectionPool>(std::move(connection), connectionCount) };
connectionPool->setTimeout(std::chrono::seconds(10)); connectionPool->setTimeout(std::chrono::seconds{ 10 });
_connectionPool = std::move(connectionPool); _connectionPool = std::move(connectionPool);
} }
Db::~Db() void Db::executeSql(const std::string& sql)
{ {
LMS_LOG(DB, DEBUG) << "Optimizing db..."; ScopedConnection connection{ *_connectionPool };
executeSql("pragma optimize");
LMS_LOG(DB, DEBUG) << "Optimizing db DONE";
}
void
Db::executeSql(const std::string& sql)
{
ScopedConnection connection {*_connectionPool};
connection->executeSql(sql); connection->executeSql(sql);
} }
Session& Session& Db::getTLSSession()
Db::getTLSSession() {
{ static thread_local Session* tlsSession{};
static thread_local Session* tlsSession {};
if (!tlsSession) if (!tlsSession)
{ {
auto newSession {std::make_unique<Session>(*this)}; auto newSession{ std::make_unique<Session>(*this) };
tlsSession = newSession.get(); tlsSession = newSession.get();
{ {
std::scoped_lock lock {_tlsSessionsMutex}; std::scoped_lock lock{ _tlsSessionsMutex };
_tlsSessions.push_back(std::move(newSession)); _tlsSessions.push_back(std::move(newSession));
} }
} }
return *tlsSession; return *tlsSession;
} }
Db::ScopedConnection::ScopedConnection(Wt::Dbo::SqlConnectionPool& pool) Db::ScopedConnection::ScopedConnection(Wt::Dbo::SqlConnectionPool& pool)
: _connectionPool {pool} : _connectionPool{ pool }
, _connection {_connectionPool.getConnection()} , _connection{ _connectionPool.getConnection() }
{ {
} }
Db::ScopedConnection::~ScopedConnection() Db::ScopedConnection::~ScopedConnection()
{ {
_connectionPool.returnConnection(std::move(_connection)); _connectionPool.returnConnection(std::move(_connection));
} }
Wt::Dbo::SqlConnection* Db::ScopedConnection::operator->() const Wt::Dbo::SqlConnection* Db::ScopedConnection::operator->() const
{ {
return _connection.get(); return _connection.get();
} }
} // namespace Database } // namespace Database
src/libs/services/database/impl/Migration.cpp
+7 -10
View File
@@ -654,7 +654,6 @@ CREATE TABLE IF NOT EXISTS "track_backup" (
{41, migrateFromV41}, {41, migrateFromV41},
}; };
while (1)
{ {
auto uniqueTransaction{ session.createUniqueTransaction() }; auto uniqueTransaction{ session.createUniqueTransaction() };
@@ -670,26 +669,24 @@ CREATE TABLE IF NOT EXISTS "track_backup" (
throw LmsException{ outdatedMsg }; throw LmsException{ outdatedMsg };
} }
if (version == LMS_DATABASE_VERSION) if (version > LMS_DATABASE_VERSION)
{
LMS_LOG(DB, DEBUG) << "Lms database version " << LMS_DATABASE_VERSION << ": up to date!";
return;
}
else if (version > LMS_DATABASE_VERSION)
{
throw LmsException{ "Server binary outdated, please upgrade it to handle this database" }; throw LmsException{ "Server binary outdated, please upgrade it to handle this database" };
}
if (version < migrationFunctions.begin()->first) if (version < migrationFunctions.begin()->first)
throw LmsException{ outdatedMsg }; throw LmsException{ outdatedMsg };
LMS_LOG(DB, INFO) << "Migrating database from version " << version << "..."; while (version < LMS_DATABASE_VERSION)
{
LMS_LOG(DB, INFO) << "Migrating database from version " << version << " to " << version + 1 << "...";
auto itMigrationFunc{ migrationFunctions.find(version) }; auto itMigrationFunc{ migrationFunctions.find(version) };
assert(itMigrationFunc != std::cend(migrationFunctions)); assert(itMigrationFunc != std::cend(migrationFunctions));
itMigrationFunc->second(session); itMigrationFunc->second(session);
VersionInfo::get(session).modify()->setVersion(++version); VersionInfo::get(session).modify()->setVersion(++version);
LMS_LOG(DB, INFO) << "Migration complete to version " << version;
}
} }
} }
} }
src/libs/services/database/impl/Session.cpp
+47 -47
View File
@@ -46,9 +46,9 @@
namespace Database namespace Database
{ {
Session::Session(Db& db) Session::Session(Db& db)
: _db {db} : _db{ db }
{ {
_session.setConnectionPool(_db.getConnectionPool()); _session.setConnectionPool(_db.getConnectionPool());
_session.mapClass<VersionInfo>("version_info"); _session.mapClass<VersionInfo>("version_info");
@@ -69,64 +69,65 @@ Session::Session(Db& db)
_session.mapClass<TrackList>("tracklist"); _session.mapClass<TrackList>("tracklist");
_session.mapClass<TrackListEntry>("tracklist_entry"); _session.mapClass<TrackListEntry>("tracklist_entry");
_session.mapClass<User>("user"); _session.mapClass<User>("user");
} }
UniqueTransaction::UniqueTransaction(RecursiveSharedMutex& mutex, Wt::Dbo::Session& session) UniqueTransaction::UniqueTransaction(RecursiveSharedMutex& mutex, Wt::Dbo::Session& session)
: _lock {mutex}, : _lock{ mutex },
_transaction {session} _transaction{ session }
{ {
} }
SharedTransaction::SharedTransaction(RecursiveSharedMutex& mutex, Wt::Dbo::Session& session) SharedTransaction::SharedTransaction(RecursiveSharedMutex& mutex, Wt::Dbo::Session& session)
: _lock {mutex}, : _lock{ mutex },
_transaction {session} _transaction{ session }
{ {
} }
void void Session::checkUniqueLocked()
Session::checkUniqueLocked() {
{
assert(_db.getMutex().isUniqueLocked()); assert(_db.getMutex().isUniqueLocked());
} }
void void Session::checkSharedLocked()
Session::checkSharedLocked() {
{
assert(_db.getMutex().isSharedLocked()); assert(_db.getMutex().isSharedLocked());
} }
UniqueTransaction UniqueTransaction Session::createUniqueTransaction()
Session::createUniqueTransaction() {
{ return UniqueTransaction{ _db.getMutex(), _session };
return UniqueTransaction {_db.getMutex(), _session}; }
}
SharedTransaction SharedTransaction Session::createSharedTransaction()
Session::createSharedTransaction() {
{ return SharedTransaction{ _db.getMutex(), _session };
return SharedTransaction {_db.getMutex(), _session}; }
}
void void Session::prepareTables()
Session::prepareTables() {
{ LMS_LOG(DB, INFO) << "Preparing tables...";
// Creation case
// Initial creation case
try try
{ {
_session.createTables(); _session.createTables();
LMS_LOG(DB, INFO) << "Tables created"; LMS_LOG(DB, INFO) << "Tables created";
} }
catch (Wt::Dbo::Exception& e) catch (Wt::Dbo::Exception& e)
{
LMS_LOG(DB, DEBUG) << "Cannot create tables: " << e.what();
if (std::string_view{ e.what() }.find("already exists") == std::string_view::npos)
{ {
LMS_LOG(DB, ERROR) << "Cannot create tables: " << e.what(); LMS_LOG(DB, ERROR) << "Cannot create tables: " << e.what();
throw e;
}
} }
Migration::doDbMigration(*this); Migration::doDbMigration(*this);
// Indexes // Indexes
{ {
auto uniqueTransaction {createUniqueTransaction()}; auto uniqueTransaction{ createUniqueTransaction() };
_session.execute("CREATE INDEX IF NOT EXISTS artist_name_idx ON artist(name)"); _session.execute("CREATE INDEX IF NOT EXISTS artist_name_idx ON artist(name)");
_session.execute("CREATE INDEX IF NOT EXISTS artist_sort_name_nocase_idx ON artist(sort_name COLLATE NOCASE)"); _session.execute("CREATE INDEX IF NOT EXISTS artist_sort_name_nocase_idx ON artist(sort_name COLLATE NOCASE)");
_session.execute("CREATE INDEX IF NOT EXISTS artist_mbid_idx ON artist(mbid)"); _session.execute("CREATE INDEX IF NOT EXISTS artist_mbid_idx ON artist(mbid)");
@@ -170,21 +171,20 @@ Session::prepareTables()
// Initial settings tables // Initial settings tables
{ {
auto uniqueTransaction {createUniqueTransaction()}; auto uniqueTransaction{ createUniqueTransaction() };
ScanSettings::init(*this); ScanSettings::init(*this);
} }
} }
void void Session::analyze()
Session::optimize()
{
LMS_LOG(DB, DEBUG) << "Optimizing db...";
{ {
auto uniqueTransaction {createUniqueTransaction()}; LMS_LOG(DB, INFO) << "Analyzing database...";
{
auto uniqueTransaction{ createUniqueTransaction() };
_session.execute("ANALYZE"); _session.execute("ANALYZE");
} }
LMS_LOG(DB, DEBUG) << "Optimized db!"; LMS_LOG(DB, INFO) << "Database Analyze complete";
} }
} // namespace Database } // namespace Database
src/libs/services/database/include/services/database/Cluster.hpp
+4 -1
View File
@@ -21,6 +21,7 @@
#include <string> #include <string>
#include <string_view> #include <string_view>
#include <tuple>
#include <vector> #include <vector>
#include <Wt/Dbo/Dbo.h> #include <Wt/Dbo/Dbo.h>
@@ -58,8 +59,10 @@ namespace Database {
Cluster() = default; Cluster() = default;
// Find utility // Find utility
// As clusters only have a name, this is an optim to directly get the cluster names
using ClusterFindResult = std::tuple<ClusterId, std::string>;
static std::size_t getCount(Session& session); static std::size_t getCount(Session& session);
static RangeResults<ClusterId> find(Session& session, const FindParameters& range); static RangeResults<ClusterFindResult> find(Session& session, const FindParameters& range);
static pointer find(Session& session, ClusterId id); static pointer find(Session& session, ClusterId id);
static RangeResults<ClusterId> findOrphans(Session& session, Range range); static RangeResults<ClusterId> findOrphans(Session& session, Range range);
src/libs/services/database/include/services/database/Db.hpp
+10 -15
View File
@@ -27,23 +27,20 @@
namespace Database { namespace Database {
class Session; class Session;
class Db class Db
{ {
public: public:
Db(const std::filesystem::path& dbPath, std::size_t connectionCount = 10); Db(const std::filesystem::path& dbPath, std::size_t connectionCount = 10);
~Db();
Db(const Db&) = delete;
Db(Db&&) = delete;
Db& operator=(const Db&) = delete;
Db& operator=(Db&&) = delete;
Session& getTLSSession(); Session& getTLSSession();
void executeSql(const std::string& sql); void executeSql(const std::string& sql);
private: private:
Db(const Db&) = delete;
Db& operator=(const Db&) = delete;
friend class Session; friend class Session;
RecursiveSharedMutex& getMutex() { return _sharedMutex; } RecursiveSharedMutex& getMutex() { return _sharedMutex; }
@@ -55,14 +52,12 @@ class Db
ScopedConnection(Wt::Dbo::SqlConnectionPool& pool); ScopedConnection(Wt::Dbo::SqlConnectionPool& pool);
~ScopedConnection(); ~ScopedConnection();
ScopedConnection(const ScopedConnection& ) = delete;
ScopedConnection(ScopedConnection&& ) = delete;
ScopedConnection& operator=(const ScopedConnection& ) = delete;
ScopedConnection& operator=(ScopedConnection&& ) = delete;
Wt::Dbo::SqlConnection* operator->() const; Wt::Dbo::SqlConnection* operator->() const;
private: private:
ScopedConnection(const ScopedConnection&) = delete;
ScopedConnection& operator=(const ScopedConnection&) = delete;
Wt::Dbo::SqlConnectionPool& _connectionPool; Wt::Dbo::SqlConnectionPool& _connectionPool;
std::unique_ptr<Wt::Dbo::SqlConnection> _connection; std::unique_ptr<Wt::Dbo::SqlConnection> _connection;
}; };
@@ -72,7 +67,7 @@ class Db
std::mutex _tlsSessionsMutex; std::mutex _tlsSessionsMutex;
std::vector<std::unique_ptr<Session>> _tlsSessions; std::vector<std::unique_ptr<Session>> _tlsSessions;
}; };
} // namespace Database } // namespace Database
src/libs/services/database/include/services/database/Session.hpp
+6 -8
View File
@@ -52,12 +52,7 @@ namespace Database
class Session class Session
{ {
public: public:
Session (Db& database); Session(Db& database);
Session(const Session&) = delete;
Session(Session&&) = delete;
Session& operator=(const Session&) = delete;
Session& operator=(Session&&) = delete;
[[nodiscard]] UniqueTransaction createUniqueTransaction(); [[nodiscard]] UniqueTransaction createUniqueTransaction();
[[nodiscard]] SharedTransaction createSharedTransaction(); [[nodiscard]] SharedTransaction createSharedTransaction();
@@ -65,7 +60,7 @@ namespace Database
void checkUniqueLocked(); void checkUniqueLocked();
void checkSharedLocked(); void checkSharedLocked();
void optimize(); void analyze();
void prepareTables(); // need to run only once at startup void prepareTables(); // need to run only once at startup
@@ -77,7 +72,7 @@ namespace Database
{ {
checkUniqueLocked(); checkUniqueLocked();
typename Object::pointer res {Object::create(*this, std::forward<Args>(args)...)}; typename Object::pointer res{ Object::create(*this, std::forward<Args>(args)...) };
getDboSession().flush(); getDboSession().flush();
if (res->hasOnPostCreated()) if (res->hasOnPostCreated())
@@ -87,6 +82,9 @@ namespace Database
} }
private: private:
Session(const Session&) = delete;
Session& operator=(const Session&) = delete;
Db& _db; Db& _db;
Wt::Dbo::Session _session; Wt::Dbo::Session _session;
}; };
src/libs/services/database/test/Cluster.cpp
+10 -8
View File
@@ -48,13 +48,17 @@ TEST_F(DatabaseFixture, Cluster)
EXPECT_EQ(Cluster::getCount(session), 1); EXPECT_EQ(Cluster::getCount(session), 1);
EXPECT_EQ(cluster->getType()->getId(), clusterType.getId()); EXPECT_EQ(cluster->getType()->getId(), clusterType.getId());
auto clusters{ Cluster::find(session, Cluster::FindParameters {}) }; {
const auto clusters{ Cluster::find(session, Cluster::FindParameters {}) };
ASSERT_EQ(clusters.results.size(), 1); ASSERT_EQ(clusters.results.size(), 1);
EXPECT_EQ(clusters.results.front(), cluster.getId()); EXPECT_EQ(std::get<ClusterId>(clusters.results.front()), cluster.getId());
}
clusters = Cluster::findOrphans(session, Range{}); {
const auto clusters{ Cluster::findOrphans(session, Range{}) };
ASSERT_EQ(clusters.results.size(), 1); ASSERT_EQ(clusters.results.size(), 1);
EXPECT_EQ(clusters.results.front(), cluster.getId()); EXPECT_EQ(clusters.results.front(), cluster.getId());
}
auto clusterTypes{ ClusterType::find(session, Range {}) }; auto clusterTypes{ ClusterType::find(session, Range {}) };
ASSERT_EQ(clusterTypes.results.size(), 1); ASSERT_EQ(clusterTypes.results.size(), 1);
@@ -114,7 +118,7 @@ TEST_F(DatabaseFixture, Cluster_singleTrack)
auto transaction{ session.createSharedTransaction() }; auto transaction{ session.createSharedTransaction() };
auto clusters{ Cluster::find(session, Cluster::FindParameters {}.setTrack(track.getId())) }; auto clusters{ Cluster::find(session, Cluster::FindParameters {}.setTrack(track.getId())) };
ASSERT_EQ(clusters.results.size(), 1); ASSERT_EQ(clusters.results.size(), 1);
EXPECT_EQ(clusters.results.front(), cluster1.getId()); EXPECT_EQ(std::get<ClusterId>(clusters.results.front()), cluster1.getId());
} }
{ {
@@ -317,9 +321,9 @@ TEST_F(DatabaseFixture, Cluster_singleTrackSingleReleaseSingleCluster)
{ {
auto transaction{ session.createSharedTransaction() }; auto transaction{ session.createSharedTransaction() };
auto clusters{ Cluster::find(session, Cluster::FindParameters{}.setRelease(release.getId())) }; const auto clusters{ Cluster::find(session, Cluster::FindParameters{}.setRelease(release.getId())) };
ASSERT_EQ(clusters.results.size(), 1); ASSERT_EQ(clusters.results.size(), 1);
EXPECT_EQ(clusters.results.front(), cluster.getId()); EXPECT_EQ(std::get<ClusterId>(clusters.results.front()), cluster.getId());
} }
{ {
@@ -1106,5 +1110,3 @@ TEST_F(DatabaseFixture, MultipleTracksMultipleReleasesMultiClusters)
} }
} }
} }
src/libs/services/database/test/Common.cpp
+1 -1
View File
@@ -60,7 +60,7 @@ DatabaseFixture::SetUpTestCase()
{ {
Database::Session s {_tmpDb->getDb()}; Database::Session s {_tmpDb->getDb()};
s.prepareTables(); s.prepareTables();
s.optimize(); s.analyze();
// remove default created entries // remove default created entries
{ {
src/libs/services/scanner/impl/ScannerService.cpp
+1 -2
View File
@@ -299,8 +299,7 @@ ScannerService::scan(bool forceScan)
LMS_LOG(DBUPDATER, INFO) << "Scan " << (_abortScan ? "aborted" : "complete") << ". Changes = " << stats.nbChanges() << " (added = " << stats.additions << ", removed = " << stats.deletions << ", updated = " << stats.updates << "), Not changed = " << stats.skips << ", Scanned = " << stats.scans << " (errors = " << stats.errors.size() << "), features fetched = " << stats.featuresFetched << ", duplicates = " << stats.duplicates.size(); LMS_LOG(DBUPDATER, INFO) << "Scan " << (_abortScan ? "aborted" : "complete") << ". Changes = " << stats.nbChanges() << " (added = " << stats.additions << ", removed = " << stats.deletions << ", updated = " << stats.updates << "), Not changed = " << stats.skips << ", Scanned = " << stats.scans << " (errors = " << stats.errors.size() << "), features fetched = " << stats.featuresFetched << ", duplicates = " << stats.duplicates.size();
// TODO make it a scan step _dbSession.analyze();
_dbSession.optimize();
if (!_abortScan) if (!_abortScan)
{ {
src/libs/subsonic/impl/SubsonicResource.cpp
+2 -2
View File
@@ -288,12 +288,12 @@ namespace API::Subsonic
checkUserTypeIsAllowed(requestContext, itEntryPoint->second.allowedUserTypes); checkUserTypeIsAllowed(requestContext, itEntryPoint->second.allowedUserTypes);
Response resp{ (itEntryPoint->second.func)(requestContext) }; const Response resp{ (itEntryPoint->second.func)(requestContext) };
resp.write(response.out(), format); resp.write(response.out(), format);
response.setMimeType(std::string{ ResponseFormatToMimeType(format) }); response.setMimeType(std::string{ ResponseFormatToMimeType(format) });
LMS_LOG(API_SUBSONIC, DEBUG) << "Request " << requestId << " '" << requestPath << "' handled!"; LMS_LOG(API_SUBSONIC, DEBUG) << "Request " << requestId << " '" << requestPath << "' handled!";
return; return;
} }
src/libs/subsonic/impl/SubsonicResponse.cpp
+149 -74
View File
@@ -20,12 +20,8 @@
#include "SubsonicResponse.hpp" #include "SubsonicResponse.hpp"
#include <cassert> #include <cassert>
#include <Wt/Json/Array.h> #include <cmath>
#include <Wt/Json/Object.h> #include <climits>
#include <Wt/Json/Value.h>
#include <Wt/Json/Serializer.h>
#include <boost/property_tree/json_parser.hpp>
#include <boost/property_tree/xml_parser.hpp> #include <boost/property_tree/xml_parser.hpp>
#include "utils/Exception.hpp" #include "utils/Exception.hpp"
@@ -57,59 +53,66 @@ namespace API::Subsonic
_value = value; _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); 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(!_value);
assert(_children.find(key) == std::cend(_children));
_childrenArrays.emplace(key, std::vector<Node>{}); _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); 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(!_value);
assert(_children.find(key) == std::cend(_children));
_childrenValues.emplace(key, ValuesType{}); _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); 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 }); 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();})); 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); assert(!_value);
auto& values{ _childrenValues[std::string{ key }] }; auto& values{ _childrenValues[key] };
values.push_back(value); values.push_back(value);
assert(std::all_of(std::cbegin(values) + 1, std::cend(values), [&](const ValueType& value) {return value.index() == values.front().index();})); 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(); assert(!_value);
return _children[key].back(); 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(); _childrenArrays[key].emplace_back();
return _childrenArrays[key].back(); return _childrenArrays[key].back();
} }
@@ -152,22 +155,22 @@ namespace API::Subsonic
return response; 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) void Response::write(std::ostream& os, ResponseFormat format) const
{ {
switch (format) switch (format)
{ {
@@ -180,22 +183,22 @@ namespace API::Subsonic
} }
} }
void Response::writeXML(std::ostream& os) void Response::writeXML(std::ostream& os) const
{ {
std::function<boost::property_tree::ptree(const Node&)> nodeToPropertyTree = [&](const Node& node) std::function<boost::property_tree::ptree(const Node&)> nodeToPropertyTree = [&](const Node& node)
{ {
boost::property_tree::ptree res; 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)) if (std::holds_alternative<std::string>(value))
res.put("<xmlattr>." + itAttribute.first, std::get<std::string>(itAttribute.second)); res.put("<xmlattr>." + std::string{ key.get() }, std::get<std::string>(value));
else if (std::holds_alternative<bool>(itAttribute.second)) else if (std::holds_alternative<bool>(value))
res.put("<xmlattr>." + itAttribute.first, std::get<bool>(itAttribute.second)); res.put("<xmlattr>." + std::string{ key.get() }, std::get<bool>(value));
else if (std::holds_alternative<float>(itAttribute.second)) else if (std::holds_alternative<float>(value))
res.put("<xmlattr>." + itAttribute.first, std::get<float>(itAttribute.second)); res.put("<xmlattr>." + std::string{ key.get() }, std::get<float>(value));
else if (std::holds_alternative<long long>(itAttribute.second)) else if (std::holds_alternative<long long>(value))
res.put("<xmlattr>." + itAttribute.first, std::get<long long>(itAttribute.second)); res.put("<xmlattr>." + std::string{ key.get() }, std::get<long long>(value));
} }
auto valueToPropertyTree = [](const Node::ValueType& value) auto valueToPropertyTree = [](const Node::ValueType& value)
@@ -215,22 +218,21 @@ namespace API::Subsonic
} }
else else
{ {
for (const auto& [key, childNodes] : node._children) for (const auto& [key, childNode] : node._children)
{ {
for (const Node& childNode : childNodes) res.add_child(std::string{ key.get() }, nodeToPropertyTree(childNode));
res.add_child(key, nodeToPropertyTree(childNode));
} }
for (const auto& [key, childArrayNodes] : node._childrenArrays) for (const auto& [key, childArrayNodes] : node._childrenArrays)
{ {
for (const Node& childNode : childArrayNodes) 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 auto& [key, childArrayValues] : node._childrenValues)
{ {
for (const Response::Node::ValueType& value : childArrayValues) 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,136 @@ namespace API::Subsonic
boost::property_tree::write_xml(os, root); 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) bool first{ true };
{
Json::Object res;
auto valueToJsonValue{ [](const Node::ValueType& value) -> Json::Value for (const auto& [key, value] : node._attributes)
{ {
Json::Value res; if (!first)
std::visit([&](const auto& rawValue) os << ',';
{
res = Json::Value{ rawValue };
}, value);
return res;
} };
for (auto itAttribute : node._attributes) serializeEscapedString(os, key.get());
res[itAttribute.first] = valueToJsonValue(itAttribute.second); os << ':';
serializeValue(os, value);
first = false;
}
if (node._value) if (node._value)
{ {
res["value"] = valueToJsonValue(*node._value); if (!first)
os << ',';
os << "\"value\":";
serializeValue(os, *node._value);
first = false;
} }
else else
{ {
for (const auto& [key, childNodes] : node._children) for (const auto& [key, childNode] : node._children)
{ {
for (const Response::Node& childNode : childNodes) if (!first)
res[key] = nodeToJsonObject(childNode); os << ',';
serializeEscapedString(os, key.get());
os << ':';
serializeNode(os, childNode);
first = false;
} }
for (const auto& [key, childArrayNodes] : node._childrenArrays) for (const auto& [key, childArrayNodes] : node._childrenArrays)
{ {
Json::Array array; if (!first)
for (const Response::Node& childNode : childArrayNodes) os << ',';
array.emplace_back(nodeToJsonObject(childNode));
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) 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) 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) }; void Response::JsonSerializer::serializeValue(std::ostream& os, const Node::ValueType& value)
os << Json::serialize(root); {
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) const
{
JsonSerializer serializer;
serializer.serializeNode(os, _root);
} }
} // namespace } // namespace
src/libs/subsonic/impl/SubsonicResponse.hpp
+45 -23
View File
@@ -191,17 +191,30 @@ namespace API::Subsonic
class Node class Node
{ {
public: 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> 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) 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) 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) 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 else
static_assert("Unhandled type"); 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 // A Node has either a single value or an array of values or some children
void setValue(std::string_view value); void setValue(std::string_view value);
void setValue(long long value); void setValue(long long value);
Node& createChild(const std::string& key); Node& createChild(Key key);
Node& createArrayChild(const std::string& key); Node& createArrayChild(Key key);
void addChild(const std::string& key, Node node); void addChild(Key key, Node&& node);
void createEmptyArrayChild(std::string_view key); void createEmptyArrayChild(Key key);
void addArrayChild(std::string_view key, Node node); void addArrayChild(Key key, Node&& node);
void createEmptyArrayValue(std::string_view key); void createEmptyArrayValue(Key key);
void addArrayValue(std::string_view key, std::string_view value); void addArrayValue(Key key, std::string_view value);
void addArrayValue(std::string_view key, long long value); void addArrayValue(Key key, long long value);
private: private:
void setVersionAttribute(ProtocolVersion version); void setVersionAttribute(ProtocolVersion version);
friend class Response; friend class Response;
using ValueType = std::variant<std::string, bool, float, long long>; 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::optional<ValueType> _value;
std::map<std::string, std::vector<Node>> _children; std::map<Key, Node> _children;
std::map<std::string, std::vector<Node>> _childrenArrays; std::map<Key, std::vector<Node>> _childrenArrays;
using ValuesType = std::vector<ValueType>; using ValuesType = std::vector<ValueType>;
std::map<std::string, ValuesType> _childrenValues; std::map<Key, ValuesType> _childrenValues;
}; };
static Response createOkResponse(ProtocolVersion protocolVersion); static Response createOkResponse(ProtocolVersion protocolVersion);
@@ -242,16 +255,25 @@ namespace API::Subsonic
Response(Response&&) = default; Response(Response&&) = default;
Response& operator=(Response&&) = default; Response& operator=(Response&&) = default;
void addNode(const std::string& key, Node node); void addNode(Node::Key key, Node&& node);
Node& createNode(const std::string& key); Node& createNode(Node::Key key);
Node& createArrayNode(const std::string& key); Node& createArrayNode(Node::Key key);
void write(std::ostream& os, ResponseFormat format); void write(std::ostream& os, ResponseFormat format) const;
private: private:
static Response createResponseCommon(ProtocolVersion protocolVersion, const Error* error = nullptr); static Response createResponseCommon(ProtocolVersion protocolVersion, const Error* error = nullptr);
void writeJSON(std::ostream& os);
void writeXML(std::ostream& os); 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) const;
void writeXML(std::ostream& os) const;
Response() = default; Response() = default;
Node _root; Node _root;
src/libs/subsonic/impl/entrypoints/AlbumSongLists.cpp
+2 -2
View File
@@ -133,7 +133,7 @@ namespace API::Subsonic
throw NotImplementedGenericError{}; throw NotImplementedGenericError{};
Response response{ Response::createOkResponse(context.serverProtocolVersion) }; 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) for (const ReleaseId releaseId : releases.results)
{ {
@@ -153,7 +153,7 @@ namespace API::Subsonic
throw UserNotAuthorizedError{}; throw UserNotAuthorizedError{};
Response response{ Response::createOkResponse(context.serverProtocolVersion) }; 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() }; 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) }; std::size_t count{ getParameterAs<std::size_t>(context.parameters, "count").value_or(20) };
Response response{ Response::createOkResponse(context.serverProtocolVersion) }; 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() }; auto transaction{ context.dbSession.createSharedTransaction() };
@@ -236,7 +236,7 @@ namespace API::Subsonic
throw UserNotAuthorizedError{}; throw UserNotAuthorizedError{};
Response response{ Response::createOkResponse(context.serverProtocolVersion) }; 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) for (const TrackId trackId : tracks)
{ {
const Track::pointer track{ Track::find(context.dbSession, trackId) }; 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 namespace
{ {
Response::Node Response::Node createStatusResponseNode()
createStatusResponseNode()
{ {
Response::Node statusResponse; Response::Node statusResponse;
src/libs/subsonic/impl/entrypoints/Playlists.cpp
+1 -1
View File
@@ -75,7 +75,7 @@ namespace API::Subsonic
for (const TrackListEntry::pointer& entry : entries) for (const TrackListEntry::pointer& entry : entries)
playlistNode.addArrayChild("entry", createSongNode(entry->getTrack(), context.dbSession, user)); playlistNode.addArrayChild("entry", createSongNode(entry->getTrack(), context.dbSession, user));
response.addNode("playlist", playlistNode); response.addNode("playlist", std::move(playlistNode));
return response; return response;
} }
src/libs/subsonic/impl/responses/Album.cpp
+13 -24
View File
@@ -114,7 +114,7 @@ namespace API::Subsonic
if (artists.size() == 1) 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 else
{ {
@@ -124,15 +124,16 @@ namespace API::Subsonic
} }
// Report the first GENRE for this track // Report the first GENRE for this track
if (ClusterType::pointer clusterType{ ClusterType::find(dbSession, "GENRE") }) const ClusterType::pointer genreClusterType{ ClusterType::find(dbSession, "GENRE") };
if (genreClusterType)
{ {
auto clusters{ release->getClusterGroups({clusterType}, 1) }; auto clusters{ release->getClusterGroups({genreClusterType}, 1) };
if (!clusters.empty() && !clusters.front().empty()) if (!clusters.empty() && !clusters.front().empty())
albumNode.setAttribute("genre", clusters.front().front()->getName()); albumNode.setAttribute("genre", clusters.front().front()->getName());
} }
if (const Wt::WDateTime dateTime{ Service<Scrobbling::IScrobblingService>::get()->getStarredDateTime(user->getId(), release->getId()) }; dateTime.isValid()) if (const Wt::WDateTime dateTime{ Service<Scrobbling::IScrobblingService>::get()->getStarredDateTime(user->getId(), release->getId()) }; dateTime.isValid())
albumNode.setAttribute("starred", StringUtils::toISO8601String(dateTime)); // TODO report correct date/time albumNode.setAttribute("starred", StringUtils::toISO8601String(dateTime));
// OpenSubsonic specific fields (must always be set) // OpenSubsonic specific fields (must always be set)
if (!id3) if (!id3)
@@ -140,7 +141,7 @@ namespace API::Subsonic
{ {
const Wt::WDateTime dateTime{ Service<Scrobbling::IScrobblingService>::get()->getLastListenDateTime(user->getId(), release->getId()) }; 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 +149,7 @@ namespace API::Subsonic
albumNode.setAttribute("musicBrainzId", mbid ? mbid->getAsString() : ""); 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); albumNode.createEmptyArrayValue(field);
@@ -159,35 +160,23 @@ namespace API::Subsonic
params.setRelease(release->getId()); params.setRelease(release->getId());
params.setClusterType(clusterType->getId()); params.setClusterType(clusterType->getId());
for (const ClusterId clusterId : Cluster::find(dbSession, params).results) for (const auto& cluster : Cluster::find(dbSession, params).results)
{ albumNode.addArrayValue(field, std::get<std::string>(cluster));
Cluster::pointer cluster{ Cluster::find(dbSession, clusterId) };
if (cluster)
albumNode.addArrayValue(field, cluster->getName());
}
} }
} }; } };
addClusters("moods", "MOOD"); addClusters("moods", "MOOD");
// Genres // Genres
{
albumNode.createEmptyArrayChild("genres"); albumNode.createEmptyArrayChild("genres");
if (genreClusterType)
ClusterType::pointer clusterType{ ClusterType::find(dbSession, "GENRE") };
if (clusterType)
{ {
Cluster::FindParameters params; Cluster::FindParameters params;
params.setRelease(release->getId()); params.setRelease(release->getId());
params.setClusterType(clusterType->getId()); params.setClusterType(genreClusterType->getId());
for (const ClusterId clusterId : Cluster::find(dbSession, params).results) for (const auto& cluster : Cluster::find(dbSession, params).results)
{ albumNode.addArrayChild("genres", createItemGenreNode(std::get<std::string>(cluster)));
Cluster::pointer cluster{ Cluster::find(dbSession, clusterId) };
if (cluster)
albumNode.addArrayChild("genres", createItemGenreNode(cluster));
}
}
} }
albumNode.createEmptyArrayChild("artists"); albumNode.createEmptyArrayChild("artists");
src/libs/subsonic/impl/responses/ItemGenre.cpp
+2 -2
View File
@@ -23,11 +23,11 @@
namespace API::Subsonic namespace API::Subsonic
{ {
Response::Node createItemGenreNode(const Database::Cluster::pointer& cluster) Response::Node createItemGenreNode(std::string_view name)
{ {
Response::Node genreNode; Response::Node genreNode;
genreNode.setAttribute("name", cluster->getName()); genreNode.setAttribute("name", name);
return genreNode; return genreNode;
} }
src/libs/subsonic/impl/responses/ItemGenre.hpp
+2 -2
View File
@@ -19,7 +19,7 @@
#pragma once #pragma once
#include "services/database/Object.hpp" #include <string_view>
#include "SubsonicResponse.hpp" #include "SubsonicResponse.hpp"
namespace Database namespace Database
@@ -29,5 +29,5 @@ namespace Database
namespace API::Subsonic namespace API::Subsonic
{ {
Response::Node createItemGenreNode(const Database::ObjectPtr<Database::Cluster>& cluster); Response::Node createItemGenreNode(std::string_view name);
} }
src/libs/subsonic/impl/responses/Song.cpp
+10 -21
View File
@@ -152,7 +152,8 @@ namespace API::Subsonic
trackResponse.setAttribute("starred", StringUtils::toISO8601String(dateTime)); trackResponse.setAttribute("starred", StringUtils::toISO8601String(dateTime));
// Report the first GENRE for this track // Report the first GENRE for this track
if (ClusterType::pointer genreClusterType{ ClusterType::find(dbSession, "GENRE") }) const ClusterType::pointer genreClusterType{ ClusterType::find(dbSession, "GENRE") };
if (genreClusterType)
{ {
auto clusters{ track->getClusterGroups({genreClusterType}, 1) }; auto clusters{ track->getClusterGroups({genreClusterType}, 1) };
if (!clusters.empty() && !clusters.front().empty()) if (!clusters.empty() && !clusters.front().empty())
@@ -186,7 +187,7 @@ namespace API::Subsonic
} }
} }
auto addArtistLinks{ [&](std::string_view nodeName, TrackArtistLinkType type) auto addArtistLinks{ [&](Response::Node::Key nodeName, TrackArtistLinkType type)
{ {
trackResponse.createEmptyArrayChild(nodeName); trackResponse.createEmptyArrayChild(nodeName);
@@ -209,7 +210,7 @@ namespace API::Subsonic
if (release) if (release)
trackResponse.setAttribute("displayAlbumArtist", release->getArtistDisplayName()); 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); trackResponse.createEmptyArrayValue(field);
@@ -220,35 +221,23 @@ namespace API::Subsonic
params.setTrack(track->getId()); params.setTrack(track->getId());
params.setClusterType(clusterType->getId()); params.setClusterType(clusterType->getId());
for (const ClusterId clusterId : Cluster::find(dbSession, params).results) for (const auto& cluster : Cluster::find(dbSession, params).results)
{ trackResponse.addArrayValue(field, std::get<std::string>(cluster));
Cluster::pointer cluster {Cluster::find(dbSession, clusterId)};
if (cluster)
trackResponse.addArrayValue(field, cluster->getName());
}
} }
} }; } };
addClusters("moods", "MOOD"); addClusters("moods", "MOOD");
// Genres // Genres
{
trackResponse.createEmptyArrayChild("genres"); trackResponse.createEmptyArrayChild("genres");
if (genreClusterType)
ClusterType::pointer clusterType{ ClusterType::find(dbSession, "GENRE") };
if (clusterType)
{ {
Cluster::FindParameters params; Cluster::FindParameters params;
params.setTrack(track->getId()); params.setTrack(track->getId());
params.setClusterType(clusterType->getId()); params.setClusterType(genreClusterType->getId());
for (const ClusterId clusterId : Cluster::find(dbSession, params).results) for (const auto& cluster : Cluster::find(dbSession, params).results)
{ trackResponse.addArrayChild("genres", createItemGenreNode(std::get<std::string>(cluster)));
Cluster::pointer cluster{ Cluster::find(dbSession, clusterId) };
if (cluster)
trackResponse.addArrayChild("genres", createItemGenreNode(cluster));
}
}
} }
trackResponse.addChild("replayGain", createReplayGainNode(track)); trackResponse.addChild("replayGain", createReplayGainNode(track));
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/>. * along with LMS. If not, see <http://www.gnu.org/licenses/>.
*/ */
#include <thread>
#include "utils/StreamLogger.hpp" #include "utils/StreamLogger.hpp"
StreamLogger::StreamLogger(std::ostream& os, EnumSet<Severity> severities) StreamLogger::StreamLogger(std::ostream& os, EnumSet<Severity> severities)
: _os {os} : _os{ os }
, _severities {severities} , _severities{ severities }
{ {
} }
void void StreamLogger::processLog(const Log& log)
StreamLogger::processLog(const Log& log)
{ {
if (_severities.contains(log.getSeverity())) 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; 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 static const std::unordered_map<char, std::string_view> escapeMap
{ {
@@ -249,6 +249,28 @@ namespace StringUtils
return escaped; 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 escapeString(std::string_view str, std::string_view charsToEscape, char escapeChar)
{ {
std::string res; std::string res;
src/libs/utils/impl/WtLogger.cpp
+14 -3
View File
@@ -19,14 +19,25 @@
#include "utils/WtLogger.hpp" #include "utils/WtLogger.hpp"
#include <thread>
#include <sstream>
#include <Wt/WApplication.h> #include <Wt/WApplication.h>
#include <Wt/WLogger.h> #include <Wt/WLogger.h>
#include "utils/Logger.hpp" #include "utils/Logger.hpp"
void namespace
WtLogger::processLog(const Log& log)
{ {
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 Logger;
class Log class Log
{ {
public: public:
Log(Logger* logger, Module module, Severity severity); Log(Logger* logger, Module module, Severity severity);
~Log(); ~Log();
@@ -71,20 +71,22 @@ class Log
std::ostringstream& getOstream() { return _oss; } std::ostringstream& getOstream() { return _oss; }
private: private:
Log(const Log&) = delete;
Log& operator=(const Log&) = delete;
Module _module; Module _module;
Severity _severity; Severity _severity;
std::ostringstream _oss; std::ostringstream _oss;
Logger* _logger {}; Logger* _logger{};
}; };
class Logger class Logger
{ {
public: public:
virtual ~Logger() = default; virtual ~Logger() = default;
virtual void processLog(const Log& log) = 0; virtual void processLog(const Log& log) = 0;
}; };
#define LMS_LOG(module, severity) Log(Service<Logger>::get(), Module::module, Severity::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() #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 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); [[nodiscard]] std::string escapeString(std::string_view str, std::string_view charsToEscape, char escapeChar);
src/lms/main.cpp
+4 -1
View File
@@ -238,7 +238,10 @@ int main(int argc, char* argv[])
{ {
Database::Session session {database}; Database::Session session {database};
session.prepareTables(); session.prepareTables();
session.optimize();
// force optimize in case scanner aborted during a large import:
// queries may be too slow to even be able to relaunch a scan sing the web interface
session.analyze();
} }
UserInterface::LmsApplicationManager appManager; UserInterface::LmsApplicationManager appManager;