276 lines
7.4 KiB
C++
276 lines
7.4 KiB
C++
#include "./resolvebuildorder.h"
|
|
|
|
#include "./manager.h"
|
|
#include "./config.h"
|
|
#include "./utilities.h"
|
|
|
|
#include <c++utilities/misc/memory.h>
|
|
|
|
#include <iostream>
|
|
#include <sstream>
|
|
|
|
using namespace std;
|
|
using namespace ApplicationUtilities;
|
|
|
|
namespace RepoIndex {
|
|
|
|
class TaskInfo
|
|
{
|
|
public:
|
|
TaskInfo(QString name, bool onlyDependency = false, const QList<TaskInfo *> &deps = QList<TaskInfo *>());
|
|
|
|
const QString &name() const;
|
|
void setName(const QString &name);
|
|
const QList<TaskInfo *> deps() const;
|
|
void addDep(TaskInfo *dep);
|
|
bool isDone() const;
|
|
bool isVisited() const;
|
|
bool isOnlyDependency() const;
|
|
bool isPackageRequested() const;
|
|
void setPackageRequested();
|
|
void add(QList<TaskInfo *> &results);
|
|
static void addAll(const QList<TaskInfo *> &tasks, QList<TaskInfo *> &results);
|
|
static TaskInfo *find(const QList<TaskInfo *> &tasks, const QString &name);
|
|
|
|
private:
|
|
QString m_name;
|
|
QList<TaskInfo *> m_deps;
|
|
bool m_done;
|
|
bool m_visited;
|
|
bool m_onlyDep;
|
|
bool m_pkgRequested;
|
|
};
|
|
|
|
inline TaskInfo::TaskInfo(QString name, bool onlyDependency, const QList<TaskInfo *> &deps) :
|
|
m_name(name),
|
|
m_deps(deps),
|
|
m_done(false),
|
|
m_visited(false),
|
|
m_onlyDep(onlyDependency),
|
|
m_pkgRequested(false)
|
|
{}
|
|
|
|
inline const QString &TaskInfo::name() const
|
|
{
|
|
return m_name;
|
|
}
|
|
|
|
inline void TaskInfo::setName(const QString &name)
|
|
{
|
|
m_name = name;
|
|
}
|
|
|
|
inline const QList<TaskInfo *> TaskInfo::deps() const
|
|
{
|
|
return m_deps;
|
|
}
|
|
|
|
inline void TaskInfo::addDep(TaskInfo *dep)
|
|
{
|
|
m_deps << dep;
|
|
}
|
|
|
|
inline bool TaskInfo::isDone() const
|
|
{
|
|
return m_done;
|
|
}
|
|
|
|
inline bool TaskInfo::isVisited() const
|
|
{
|
|
return m_visited;
|
|
}
|
|
|
|
inline bool TaskInfo::isOnlyDependency() const
|
|
{
|
|
return m_onlyDep;
|
|
}
|
|
|
|
inline bool TaskInfo::isPackageRequested() const
|
|
{
|
|
return m_pkgRequested;
|
|
}
|
|
|
|
inline void TaskInfo::setPackageRequested()
|
|
{
|
|
m_pkgRequested = true;
|
|
}
|
|
|
|
void TaskInfo::add(QList<TaskInfo *> &results)
|
|
{
|
|
if(!isDone()) {
|
|
if(isVisited()) {
|
|
// cyclic dependency
|
|
if(isOnlyDependency()) {
|
|
// if this is only a dependency (which we don't want to build) don't care about it
|
|
return;
|
|
} else {
|
|
throw *this;
|
|
}
|
|
} else {
|
|
m_visited = true;
|
|
}
|
|
for(auto *dep : deps()) {
|
|
dep->add(results);
|
|
}
|
|
m_done = true;
|
|
if(!isOnlyDependency()) {
|
|
results << this;
|
|
}
|
|
}
|
|
}
|
|
|
|
void TaskInfo::addAll(const QList<TaskInfo *> &tasks, QList<TaskInfo *> &results)
|
|
{
|
|
for(auto *task : tasks) {
|
|
task->add(results);
|
|
}
|
|
}
|
|
|
|
TaskInfo *TaskInfo::find(const QList<TaskInfo *> &tasks, const QString &name)
|
|
{
|
|
for(auto *task : tasks) {
|
|
if(task->name() == name) {
|
|
return task;
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
template<class ListType>
|
|
class DestroyList
|
|
{
|
|
public:
|
|
DestroyList(ListType &list) :
|
|
m_list(list)
|
|
{}
|
|
|
|
~DestroyList()
|
|
{
|
|
qDeleteAll(m_list);
|
|
}
|
|
|
|
private:
|
|
ListType &m_list;
|
|
};
|
|
|
|
BuildOrderResolver::BuildOrderResolver(const Manager &manager) :
|
|
m_manager(manager)
|
|
{}
|
|
|
|
QStringList BuildOrderResolver::resolve(const StringVector &packages)
|
|
{
|
|
cerr << shchar << "Getting package information ..." << endl;
|
|
m_tasks.clear();
|
|
m_tasks.reserve(packages.size() * 2);
|
|
m_dependenciesToBeRequested.clear();
|
|
try {
|
|
// add a task for each specified package
|
|
for(const auto &pkgName : packages) {
|
|
m_tasks << new TaskInfo(QString::fromLocal8Bit(pkgName.data()));
|
|
}
|
|
// find specified packages and their dependencies
|
|
for(int i = 0, size = m_tasks.size(); i != size; ++i) {
|
|
addDeps(m_tasks.at(i));
|
|
}
|
|
//for(auto *task : m_tasks) {
|
|
// addDeps(task);
|
|
//}
|
|
while(!m_dependenciesToBeRequested.isEmpty()) {
|
|
cerr << shchar << "Dependencies to be requested:";
|
|
for(const Dependency &dep : m_dependenciesToBeRequested) {
|
|
cerr << ' ' << dep.name.toStdString();
|
|
}
|
|
cerr << endl;
|
|
// TODO: do requests
|
|
|
|
m_dependenciesToBeRequested.clear();
|
|
}
|
|
if(m_manager.config().isVerbose()) {
|
|
cerr << shchar << "Relevant packages:";
|
|
for(const auto *task : m_tasks) {
|
|
cerr << ' ' << task->name().toLocal8Bit().data();
|
|
}
|
|
cerr << endl;
|
|
}
|
|
// topo sort
|
|
QList<TaskInfo *> results;
|
|
try {
|
|
results.reserve(packages.size());
|
|
TaskInfo::addAll(m_tasks, results);
|
|
QStringList names;
|
|
names.reserve(results.size());
|
|
for(const auto *res : results) {
|
|
names << res->name();
|
|
}
|
|
return names;
|
|
} catch (const TaskInfo &cyclic) {
|
|
throw runtime_error("Can't resolve build order; the package " + cyclic.name().toStdString() + " is a cyclic dependency.");
|
|
}
|
|
} catch(...) {
|
|
qDeleteAll(m_tasks);
|
|
throw;
|
|
}
|
|
}
|
|
|
|
void BuildOrderResolver::printResults(const QStringList &results)
|
|
{
|
|
if(useShSyntax) {
|
|
Utilities::printBashArray(cout, "REPOINDEX_RESULTS", results);
|
|
} else {
|
|
Utilities::printValues(cout, "Results", results);
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* \brief Finds the package for the specified \a task and then adds dependencies.
|
|
*/
|
|
void BuildOrderResolver::addDeps(TaskInfo *task)
|
|
{
|
|
Dependency dep(task->name(), QString());
|
|
if(const auto pkg = m_manager.packageProviding(dep)) {
|
|
task->setName(pkg->name()); // update the name to ensure we have the acutal package name and not just a "provides" name
|
|
addDeps(task, pkg->dependencies());
|
|
} else if(!task->isPackageRequested()) {
|
|
task->setPackageRequested();
|
|
m_dependenciesToBeRequested << dep;
|
|
} else {
|
|
stringstream ss;
|
|
ss << "The specified package \"" << task->name().toLocal8Bit().data() << "\" could not be found; TODO: search AUR for package, add AUR deps to the packages we want to build";
|
|
throw runtime_error(ss.str());
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* \brief Finds packages for the the specified \a dependencies and adds them to the specified \a task.
|
|
*/
|
|
void BuildOrderResolver::addDeps(TaskInfo *task, const QList<Dependency> &dependencies)
|
|
{
|
|
for(auto &dep : dependencies) {
|
|
if(const auto depPkg = m_manager.packageProviding(dep)) {
|
|
auto *depTask = TaskInfo::find(m_tasks, depPkg->name());
|
|
if(depTask) {
|
|
// we've already added a task for this dependency
|
|
// adds dependency task to the dependencies of "parent" task
|
|
task->addDep(depTask);
|
|
} else {
|
|
// create new task
|
|
m_tasks << (depTask = new TaskInfo(depPkg->name(), true));
|
|
// adds dependency task to the dependencies of "parent" task
|
|
task->addDep(depTask);
|
|
// add dependencies of the dependency
|
|
addDeps(depTask, depPkg->dependencies());
|
|
}
|
|
} else if(!task->isPackageRequested()) {
|
|
task->setPackageRequested();
|
|
m_dependenciesToBeRequested << dep;
|
|
} else {
|
|
stringstream ss;
|
|
ss << "The dependency \"" << dep.name.toLocal8Bit().data() << "\" could not be found; TODO: search AUR for package, add AUR deps to the packages we want to build";
|
|
throw runtime_error(ss.str());
|
|
}
|
|
}
|
|
}
|
|
|
|
} // namespace PackageManagement
|
|
|