597 lines
16 KiB
C++
597 lines
16 KiB
C++
#ifndef PACKAGEMANAGEMENT_PACKAGESOURCE_H
|
|
#define PACKAGEMANAGEMENT_PACKAGESOURCE_H
|
|
|
|
#include "./package.h"
|
|
|
|
#include <QObject>
|
|
#include <QFuture>
|
|
#include <QJsonObject>
|
|
#include <QReadWriteLock>
|
|
|
|
#include <memory>
|
|
#include <functional>
|
|
|
|
QT_FORWARD_DECLARE_CLASS(QNetworkReply)
|
|
|
|
namespace RepoIndex {
|
|
|
|
class UpgradeLookupResults;
|
|
|
|
class Reply : public QObject
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
Reply(QNetworkReply *networkReply);
|
|
Reply(const QList<QNetworkReply *> networkReplies);
|
|
const QString &error() const;
|
|
|
|
Q_SIGNALS:
|
|
void resultsAvailable();
|
|
|
|
private Q_SLOTS:
|
|
void replyFinished();
|
|
|
|
private:
|
|
virtual void processData(QNetworkReply *reply) = 0;
|
|
|
|
protected:
|
|
QList<QNetworkReply *> m_networkReplies;
|
|
unsigned int m_remainingReplies;
|
|
QString m_error;
|
|
};
|
|
|
|
inline const QString &Reply::error() const
|
|
{
|
|
return m_error;
|
|
}
|
|
|
|
class PackageReply : public Reply
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
PackageReply(QNetworkReply *networkReply, const QStringList &requestedPackages, Repository *repo);
|
|
PackageReply(const QList<QNetworkReply *> &networkReplies, const QStringList &requestedPackages, Repository *repo);
|
|
const QStringList &requestedPackages() const;
|
|
Repository *repository();
|
|
const Repository *repository() const;
|
|
|
|
protected:
|
|
QStringList m_requestedPackages;
|
|
Repository *m_repo;
|
|
};
|
|
|
|
inline PackageReply::PackageReply(QNetworkReply *networkReply, const QStringList &requestedPackages, Repository *repo) :
|
|
Reply(networkReply),
|
|
m_requestedPackages(requestedPackages),
|
|
m_repo(repo)
|
|
{}
|
|
|
|
inline PackageReply::PackageReply(const QList<QNetworkReply *> &networkReplies, const QStringList &requestedPackages, Repository *repo) :
|
|
Reply(networkReplies),
|
|
m_requestedPackages(requestedPackages),
|
|
m_repo(repo)
|
|
{}
|
|
|
|
inline const QStringList &PackageReply::requestedPackages() const
|
|
{
|
|
return m_requestedPackages;
|
|
}
|
|
|
|
inline Repository *PackageReply::repository()
|
|
{
|
|
return m_repo;
|
|
}
|
|
|
|
inline const Repository *PackageReply::repository() const
|
|
{
|
|
return m_repo;
|
|
}
|
|
|
|
class SuggestionsReply : public Reply
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
SuggestionsReply(QNetworkReply *networkReply, const QString &term, Repository *repo);
|
|
const Repository *repository() const;
|
|
QJsonObject suggestions() const;
|
|
|
|
protected:
|
|
QString m_term;
|
|
Repository *m_repo;
|
|
};
|
|
|
|
inline SuggestionsReply::SuggestionsReply(QNetworkReply *networkReply, const QString &term, Repository *repo) :
|
|
Reply(networkReply),
|
|
m_term(term),
|
|
m_repo(repo)
|
|
{}
|
|
|
|
inline const Repository *SuggestionsReply::repository() const
|
|
{
|
|
return m_repo;
|
|
}
|
|
|
|
class PackageLoader
|
|
{
|
|
public:
|
|
QFuture<void> &future();
|
|
virtual ~PackageLoader();
|
|
|
|
protected:
|
|
PackageLoader();
|
|
QMutex m_mutex;
|
|
QFuture<void> m_future;
|
|
};
|
|
|
|
inline PackageLoader::PackageLoader()
|
|
{}
|
|
|
|
inline PackageLoader::~PackageLoader()
|
|
{}
|
|
|
|
inline QFuture<void> &PackageLoader::future()
|
|
{
|
|
return m_future;
|
|
}
|
|
|
|
/*!
|
|
* \brief The RepositoryType enum specifies the type of a repository object.
|
|
*/
|
|
enum class RepositoryType
|
|
{
|
|
AlpmDatabase, /*! The repository is an AlpmDataBase instance. */
|
|
UserRepository, /*! The repository is a UserRepository instance. */
|
|
Other /*! The repository type is unknown. */
|
|
};
|
|
|
|
/*!
|
|
* \brief The PackageDetail enum is used to refer to some kind of information about a package.
|
|
*/
|
|
enum class PackageDetail
|
|
{
|
|
Basics, /*! Basic information about the package such as knowing it exists, its name, version and description. */
|
|
Dependencies, /*! The runtime dependencies of the package. */
|
|
SourceInfo, /*! The source info such as make dependencies of the package. */
|
|
PackageInfo, /*! Information related to a specific package (pkg-file). */
|
|
AllAvailable /*! All available package details. */
|
|
};
|
|
|
|
/*!
|
|
* \brief The PackageDetailAvailability enum describes when some kind of information about a package
|
|
* becomes available.
|
|
*/
|
|
enum class PackageDetailAvailability
|
|
{
|
|
Never, /*! The information is not available and can't be requested. */
|
|
Immediately, /*! The information is available immediately after the repository object has been constructed. */
|
|
Request, /*! The information is available after the requestPackageInfo() method has been called for the package. */
|
|
FullRequest /*! The information is available after the requestFullPackageInfo() method has been called for the package. */
|
|
};
|
|
|
|
/*!
|
|
* \brief The RepositoryUsage enum specifies the usage of a repository.
|
|
*/
|
|
enum class RepositoryUsage {
|
|
None = 0,
|
|
Sync = 1, /*! The repository is used when synchronizing. */
|
|
Search = (1 << 1), /*! The repository is used when searching. */
|
|
Install = (1 << 2), /*! The repository is used to install packages. */
|
|
Upgrade = (1 << 3), /*! The repository is used to upgrade packages. */
|
|
All = (1 << 4) - 1, /*! The reposiotry is used for everything. */
|
|
};
|
|
|
|
constexpr bool operator &(RepositoryUsage lhs, RepositoryUsage rhs)
|
|
{
|
|
return (static_cast<int>(lhs) & static_cast<int>(rhs)) != 0;
|
|
}
|
|
|
|
inline RepositoryUsage &operator |=(RepositoryUsage &lhs, RepositoryUsage rhs)
|
|
{
|
|
lhs = static_cast<RepositoryUsage>(static_cast<int>(lhs) | static_cast<int>(rhs));
|
|
return lhs;
|
|
}
|
|
|
|
class Repository : public QObject
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
~Repository();
|
|
|
|
virtual RepositoryType type() const = 0;
|
|
|
|
// general meta data
|
|
bool isBusy() const;
|
|
std::uint32_t index() const;
|
|
const QString &name() const;
|
|
const QString &description() const;
|
|
const std::map<QString, std::unique_ptr<Package> > &packages() const;
|
|
std::map<QString, std::unique_ptr<Package> > &packages();
|
|
const QStringList packageNames() const;
|
|
RepositoryUsage usage() const;
|
|
bool isSourceOnly() const;
|
|
bool isPackageOnly() const;
|
|
std::map<QString, QList<Package *> > &groups();
|
|
const std::map<QString, QList<Package *> > &groups() const;
|
|
Q_SLOT void updateGroups();
|
|
const QStringList &serverUrls() const;
|
|
QStringList &serverUrls();
|
|
SignatureLevel sigLevel() const;
|
|
void setSigLevel(SignatureLevel sigLevel);
|
|
|
|
// gathering data
|
|
Q_SLOT PackageLoader *init();
|
|
void initAsSoonAsPossible();
|
|
void asSoonAsPossible(std::function<void(void)> operation);
|
|
virtual PackageLoader *internalInit();
|
|
virtual PackageDetailAvailability requestsRequired(PackageDetail packageDetail = PackageDetail::Basics) const;
|
|
virtual SuggestionsReply *requestSuggestions(const QString &phrase);
|
|
virtual PackageReply *requestPackageInfo(const QStringList &packageNames, bool forceUpdate = false);
|
|
virtual PackageReply *requestFullPackageInfo(const QStringList &packageNames, bool forceUpdate = false);
|
|
|
|
// package search
|
|
const Package *packageByName(const QString &name) const;
|
|
Package *packageByName(const QString &name);
|
|
const Package *packageProviding(const Dependency &dependency) const;
|
|
Package *packageProviding(const Dependency &dependency);
|
|
QList<const Package *> packagesProviding(const Dependency &dependency) const;
|
|
QList<Package *> packageByFilter(std::function<bool (const Package *)> pred);
|
|
QFuture<void> computeRequiredBy(const QList<Repository *> &relevantRepositories, bool forceUpdate = false);
|
|
QJsonObject suggestions(const QString &term) const;
|
|
|
|
// upgrade lookup
|
|
const QList<Repository *> &upgradeSources() const;
|
|
QList<Repository *> &upgradeSources();
|
|
QJsonArray upgradeSourcesJsonArray() const;
|
|
void checkForUpgrades(UpgradeLookupResults &results) const;
|
|
void checkForUpgrades(UpgradeLookupResults &results, const QList<Repository *> &upgradeSources) const;
|
|
|
|
// build system
|
|
const QString &sourcesDirectory() const;
|
|
void setSourcesDirectory(const QString &dir);
|
|
const QString &packagesDirectory() const;
|
|
void setPackagesDirectory(const QString &dir);
|
|
|
|
// JSON serialization
|
|
QJsonArray packageNamesJsonArray() const;
|
|
QJsonObject packagesObjectSkeleton() const;
|
|
QJsonObject basicInfo(bool includeName = false) const;
|
|
QJsonObject groupInfo() const;
|
|
|
|
// caching
|
|
bool isCachingUseful() const;
|
|
void writeToCacheStream(QDataStream &out);
|
|
void restoreFromCacheStream(QDataStream &in, bool skipOutdated = true);
|
|
virtual void writeSpecificCacheHeader(QDataStream &out);
|
|
virtual std::unique_ptr<Package> emptyPackage();
|
|
virtual void restoreSpecificCacheHeader(QDataStream &in);
|
|
CppUtilities::TimeSpan maxPackageAge() const;
|
|
void setMaxPackageAge(CppUtilities::TimeSpan maxPackageAge);
|
|
void cleanOutdatedPackages();
|
|
bool hasOutdatedPackages();
|
|
void wipePackages();
|
|
|
|
// parsing src/pkg info
|
|
static void parsePkgInfo(const QByteArray &pkgInfo, QString &name, QList<QPair<QString, QString> > packageInfo);
|
|
static void parseDescriptions(const QList<QByteArray> &descriptions, QString &name, QList<QPair<QString, QStringList> > &fields);
|
|
QList<Package *> addPackagesFromSrcInfo(const QByteArray &srcInfo, CppUtilities::DateTime timeStamp);
|
|
Package *addPackageFromDescription(QString name, const QList<QByteArray> &descriptions, PackageOrigin origin, CppUtilities::DateTime timeStamp);
|
|
|
|
// thread synchronization
|
|
QReadWriteLock *lock() const;
|
|
|
|
static const std::uint32_t invalidIndex = static_cast<std::uint32_t>(-1);
|
|
|
|
Q_SIGNALS:
|
|
/*!
|
|
* \brief Emitted after initialization has finished.
|
|
*/
|
|
void initialized();
|
|
|
|
/*!
|
|
* \brief Emitted after required-by computation has finished.
|
|
*/
|
|
void requiredByComputed();
|
|
|
|
/*!
|
|
* \brief Indicates the repository is not busy anymore; emitted after either initialization or required-by computation has finished.
|
|
*/
|
|
void available();
|
|
|
|
protected Q_SLOTS:
|
|
void addBusyFlag();
|
|
void removeBusyFlag();
|
|
|
|
private Q_SLOTS:
|
|
void discardPackageLoader();
|
|
|
|
protected:
|
|
explicit Repository(const QString &name, std::uint32_t index = invalidIndex, QObject *parent = nullptr);
|
|
|
|
std::uint32_t m_index;
|
|
QString m_name;
|
|
QString m_description;
|
|
std::map<QString, std::unique_ptr<Package> > m_packages;
|
|
CppUtilities::TimeSpan m_maxPackageAge;
|
|
RepositoryUsage m_usage;
|
|
std::map<QString, QList<Package *> > m_groups;
|
|
QStringList m_serverUrls;
|
|
SignatureLevel m_sigLevel;
|
|
QList<Repository *> m_upgradeSources;
|
|
QString m_srcDir;
|
|
QString m_pkgDir;
|
|
QAtomicInteger<std::uint8_t> m_isBusy;
|
|
std::unique_ptr<PackageLoader> m_loader;
|
|
|
|
private:
|
|
QReadWriteLock m_lock;
|
|
};
|
|
|
|
/*!
|
|
* \brief Returns the suggestions.
|
|
*/
|
|
inline QJsonObject SuggestionsReply::suggestions() const
|
|
{
|
|
return m_repo->suggestions(m_term);
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns an indication whether the repository is busy (either initializing or computing required-by).
|
|
*
|
|
* In this case the repository shouldn't be touched until the available() signal is emitted.
|
|
*
|
|
* \remarks This method is thread-safe.
|
|
*/
|
|
inline bool Repository::isBusy() const
|
|
{
|
|
return m_isBusy.load() != 0;
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the index of the repository.
|
|
*
|
|
* The index is used to sort the repositories by their occurrence the configuration files.
|
|
*/
|
|
inline std::uint32_t Repository::index() const
|
|
{
|
|
return m_index;
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the name.
|
|
*/
|
|
inline const QString &Repository::name() const
|
|
{
|
|
return m_name;
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the description.
|
|
*/
|
|
inline const QString &Repository::description() const
|
|
{
|
|
return m_description;
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns whether the repository only has sources but no built packages.
|
|
*/
|
|
inline bool Repository::isSourceOnly() const
|
|
{
|
|
return requestsRequired(PackageDetail::PackageInfo) == PackageDetailAvailability::Never;
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns whether the repository only has built packages but no sources.
|
|
*/
|
|
inline bool Repository::isPackageOnly() const
|
|
{
|
|
return requestsRequired(PackageDetail::SourceInfo) == PackageDetailAvailability::Never;
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the packages.
|
|
*/
|
|
inline const std::map<QString, std::unique_ptr<Package> > &Repository::packages() const
|
|
{
|
|
return m_packages;
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the packages.
|
|
*/
|
|
inline std::map<QString, std::unique_ptr<Package> > &Repository::packages()
|
|
{
|
|
return m_packages;
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the package with the specified \a name or nullptr if the package can not be found.
|
|
* \remarks Ownership remains by this instance.
|
|
*/
|
|
inline const Package *Repository::packageByName(const QString &name) const
|
|
{
|
|
try {
|
|
return m_packages.at(name).get();
|
|
} catch(const std::out_of_range &) {
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the package with the specified \a name or nullptr if the package can not be found.
|
|
* \remarks Ownership remains by this instance.
|
|
*/
|
|
inline Package *Repository::packageByName(const QString &name)
|
|
{
|
|
try {
|
|
return m_packages.at(name).get();
|
|
} catch(const std::out_of_range &) {
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the operations the repository is used for.
|
|
*/
|
|
inline RepositoryUsage Repository::usage() const
|
|
{
|
|
return m_usage;
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the groups the packages of the repository belong to.
|
|
*/
|
|
inline std::map<QString, QList<Package *> > &Repository::groups()
|
|
{
|
|
return m_groups;
|
|
}
|
|
|
|
|
|
/*!
|
|
* \brief Returns the groups the packages of the repository belong to.
|
|
*/
|
|
inline const std::map<QString, QList<Package *> > &Repository::groups() const
|
|
{
|
|
return m_groups;
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the server URLs.
|
|
*/
|
|
inline const QStringList &Repository::serverUrls() const
|
|
{
|
|
return m_serverUrls;
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the server URLs.
|
|
* \remarks This non-const version is used by the manager to add the servers.
|
|
*/
|
|
inline QStringList &Repository::serverUrls()
|
|
{
|
|
return m_serverUrls;
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the signature level of the database.
|
|
*/
|
|
inline SignatureLevel Repository::sigLevel() const
|
|
{
|
|
return m_sigLevel;
|
|
}
|
|
|
|
/*!
|
|
* \brief Sets the signature level.
|
|
*/
|
|
inline void Repository::setSigLevel(SignatureLevel sigLevel)
|
|
{
|
|
m_sigLevel = sigLevel;
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the upgrade sources for the repository.
|
|
*/
|
|
inline const QList<Repository *> &Repository::upgradeSources() const
|
|
{
|
|
return m_upgradeSources;
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the upgrade sources for the repository.
|
|
* \remarks This non-const version is used by the manager to add upgrade sources.
|
|
*/
|
|
inline QList<Repository *> &Repository::upgradeSources()
|
|
{
|
|
return m_upgradeSources;
|
|
}
|
|
|
|
inline void Repository::checkForUpgrades(UpgradeLookupResults &results) const
|
|
{
|
|
checkForUpgrades(results, upgradeSources());
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the path of the local sources directory.
|
|
*/
|
|
inline const QString &Repository::sourcesDirectory() const
|
|
{
|
|
return m_srcDir;
|
|
}
|
|
|
|
/*!
|
|
* \brief Sets the path of the local sources directory.
|
|
*/
|
|
inline void Repository::setSourcesDirectory(const QString &dir)
|
|
{
|
|
m_srcDir = dir;
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the path of the local packages directory.
|
|
*/
|
|
inline const QString &Repository::packagesDirectory() const
|
|
{
|
|
return m_pkgDir;
|
|
}
|
|
|
|
/*!
|
|
* \brief Sets the path of the local packages directory.
|
|
*/
|
|
inline void Repository::setPackagesDirectory(const QString &dir)
|
|
{
|
|
m_pkgDir = dir;
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns whether caching this repository is useful.
|
|
*/
|
|
inline bool Repository::isCachingUseful() const
|
|
{
|
|
switch(requestsRequired(PackageDetail::AllAvailable)) {
|
|
case PackageDetailAvailability::Request:
|
|
case PackageDetailAvailability::FullRequest:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the max package age.
|
|
* \sa setMaxPackageAge()
|
|
*/
|
|
inline CppUtilities::TimeSpan Repository::maxPackageAge() const
|
|
{
|
|
return m_maxPackageAge;
|
|
}
|
|
|
|
/*!
|
|
* \brief Sets the max package age which is used by the cleanOutdatedPackages() and
|
|
* the hasOutdatedPackages() method.
|
|
*/
|
|
inline void Repository::setMaxPackageAge(CppUtilities::TimeSpan maxPackageAge)
|
|
{
|
|
m_maxPackageAge = maxPackageAge;
|
|
}
|
|
|
|
/*!
|
|
* \brief Wipes all packages.
|
|
*/
|
|
inline void Repository::wipePackages()
|
|
{
|
|
m_packages.clear();
|
|
m_groups.clear();
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the read-write lock used for thread-synchronization.
|
|
*/
|
|
inline QReadWriteLock *Repository::lock() const
|
|
{
|
|
return const_cast<QReadWriteLock *>(&m_lock);
|
|
}
|
|
|
|
} // namespace PackageManagement
|
|
|
|
#endif // PACKAGEMANAGEMENT_PACKAGESOURCE_H
|