int mpkgSys::requestUninstall(string package_name, mpkgDatabase *db, DependencyTracker *DepTracker, bool purge)
{
//printf("requestUninstall by name !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
mDebug("requestUninstall of " + package_name);
SQLRecord sqlSearch;
sqlSearch.addField("package_name", package_name);
if (!purge) sqlSearch.addField("package_installed", 1);
else sqlSearch.addField("package_configexist",1);
PACKAGE_LIST candidates;
//printf("SLOW GET_PACKAGELIST CALL: %s %d\n", __func__, __LINE__);
int ret = db->get_packagelist(sqlSearch, &candidates, true, false);
mDebug("candidates to uninstall size = " + IntToStr(candidates.size()));
int id=-1;
if (ret == 0)
{
if (candidates.size()>1)
{
mError(_("Ambiguity in uninstall: multiple packages with some name are installed"));
return MPKGERROR_AMBIGUITY;
}
if (candidates.IsEmpty())
{
mError(_("Cannot remove package ") + package_name + _(": not installed"));
return MPKGERROR_NOPACKAGE;
}
id = candidates[0].get_id();
if (id>=0)
{
return requestUninstall(id, db, DepTracker, purge);
}
else return MPKGERROR_NOPACKAGE;
}
else return ret;
}
int mpkgSys::update_repository_data(mpkgDatabase *db)//, DependencyTracker *DepTracker)
{
// Функция, с которой начинается обновление данных.
Repository *rep = new Repository; // Объект репозиториев
vector< pair<string, string> > package_descriptions;
rep->package_descriptions = &package_descriptions; // Add pointer to package descriptions
PACKAGE_LIST *availablePackages = new PACKAGE_LIST; // Список пакетов, полученных из всех репозиториев...
PACKAGE_LIST *tmpPackages = new PACKAGE_LIST; // Список пакетов, полученных из текущего репозитория (временное хранилище)
// А есть ли у нас вообще репозитории? Может нам и ловить-то нечего?...
// Впрочем, надо все равно пойти на принцип и пометить все пакеты как недоступные. Ибо это действительно так.
// Поэтому - проверка устранена.
if (!dialogMode) {
#ifdef X86_64
say(_("Updating package data from %ld repository(s)...\n"), REPOSITORY_LIST.size());
#else
say(_("Updating package data from %d repository(s)...\n"), REPOSITORY_LIST.size());
#endif
}
int total_packages=0; // Счетчик полученных пакетов.
// Поехали! Запрашиваем каждый репозиторий через функцию get_index()
unsigned int cnt=1;
pData.clear();
for (size_t i=0; i<REPOSITORY_LIST.size(); ++i) {
pData.addItem(REPOSITORY_LIST[i], 1, ITEMSTATE_INPROGRESS);
pData.setItemCurrentAction(i, _("retrieving index"));
}
for (size_t i=0; i<REPOSITORY_LIST.size(); ++i) {
delete tmpPackages;
tmpPackages = new PACKAGE_LIST; //Очищаем временный список.
pData.setItemChanged(i);
_cmdOptions["hide_download_errors"] = "true";
rep->get_index(REPOSITORY_LIST[i], tmpPackages); // Получаем список пакетов.
_cmdOptions["hide_download_errors"] = "false";
pData.increaseItemProgress(i);
pData.setItemState(i, ITEMSTATE_FINISHED);
cnt++;
if (!tmpPackages->IsEmpty()) // Если мы таки получили что-то, добавляем это в список.
{
total_packages+=tmpPackages->size(); // Увеличим счетчик
availablePackages->add_list(*tmpPackages); // Прибавляем данные к общему списку.
}
cnt++;
}
delete rep;
delete tmpPackages;
// Вот тут-то и начинается самое главное. Вызываем фильтрацию пакетов (действие будет происходить в функции updateRepositoryData.
int ret=db->updateRepositoryData(availablePackages);
// Now - update package descriptions
updatePackageDescriptions(package_descriptions);
if (!dialogMode) say(_("Update complete.\n"));
pData.clear();
return ret;
}
// Overloaded for list
map<const PACKAGE *, PkgScanResults> checkRevDeps(const PACKAGE_LIST &pkgList, bool fast, bool skip_symbols) {
map<const PACKAGE *, PkgScanResults> ret;
for (size_t i=0; i<pkgList.size(); ++i) {
// If not installed - skip it
if (!pkgList[i].installed()) continue;
fprintf(stderr, "[%d/%d] %s\n", (int) i+1, (int) pkgList.size(), pkgList[i].get_name().c_str());
ret[&pkgList[i]] = checkRevDeps(pkgList[i], fast, skip_symbols);
if (ret[&pkgList[i]].size()>0) fprintf(stderr, "\t%sERRORS:%s %d\n", CL_RED, CL_WHITE, (int) ret[&pkgList[i]].size());
}
return ret;
}
void mpkgSys::clean_queue(mpkgDatabase *db) {
PACKAGE_LIST toInstall;
SQLRecord sqlSearch;
sqlSearch.setSearchMode(SEARCH_IN);
sqlSearch.addField("package_action", ST_INSTALL);
sqlSearch.addField("package_action", ST_REMOVE);
sqlSearch.addField("package_action", ST_PURGE);
sqlSearch.addField("package_action", ST_REPAIR);
sqlSearch.addField("package_action", ST_UPDATE);
db->get_packagelist(sqlSearch, &toInstall, true);
for (size_t i=0; i<toInstall.size(); ++i) {
db->set_action(toInstall[i].get_id(), ST_NONE, "clean");
}
db->clear_unreachable_packages();
}
bool mpkg::repair(string fname)
{
SQLRecord sqlSearch;
sqlSearch.addField("package_name", &fname);
sqlSearch.addField("package_installed", 1);
PACKAGE_LIST p;
get_packagelist(&sqlSearch, &p);
if (p.size()==1)
{
return repair(p.get_package(0));
}
else {
say(_("Cannot repair or reinstall package %s: it is not installed\n"), fname.c_str());
return false;
}
}
bool mpkg::checkPackageIntegrity(string pkgName)
{
SQLRecord sqlSearch;
sqlSearch.addField("package_name", &pkgName);
sqlSearch.addField("package_installed", ST_INSTALLED);
PACKAGE_LIST table;
get_packagelist(&sqlSearch, &table);
if (table.size()==0)
{
mError(_("No package \"") + pkgName + _("\" is installed"));
return true;
}
if (table.size()!=1)
{
mError(_("Received ") + IntToStr(table.size()) + _(" packages, ambiguity!"));
return false;
}
return checkPackageIntegrity(table.get_package(0));
}
int mpkgSys::requestInstallGroup(string groupName, mpkgDatabase *db, DependencyTracker *DepTracker)
{
mDebug("requesting data");
SQLRecord sqlSearch;
PACKAGE_LIST candidates;
//printf("SLOW GET_PACKAGELIST CALL: %s %d\n", __func__, __LINE__);
db->get_packagelist(sqlSearch, &candidates, true, false);
db->get_full_taglist(&candidates);
vector<string> install_list;
for (size_t i=0; i<candidates.size(); ++i) {
for (unsigned int t=0; t<candidates[i].get_tags().size(); ++t) {
if (candidates[i].get_tags().at(t)==groupName) {
install_list.push_back(candidates[i].get_name());
}
}
}
mDebug("Requesting to install " + IntToStr(install_list.size()) + " packages from group " + groupName);
vector<string> versions, builds;
requestInstall(install_list,versions, builds, db, DepTracker);
return 0;
}
void EngineWindow::prepareData(int argc, char **argv) {
vector<string> fname, errorList;
QString text = tr("Errors detected:\n");
for (int i=1; i<argc; i++) {
fname.push_back((string) argv[i]);
}
int ret_install = db->install(fname, NULL, NULL, &errorList);
int ret_dep = db->DepTracker->renderData();
if (ret_install!=0) {
text += tr("some packages not found or already installed\n");
}
if (ret_dep!=0) {
text += tr("some packages have dependency errors\n");
}
PACKAGE_LIST iList = db->DepTracker->get_install_list();
PACKAGE_LIST rList = db->DepTracker->get_remove_list();
PACKAGE_LIST fList = db->DepTracker->get_failure_list();
filterDupes(&iList, false);
filterDupes(&rList, false);
filterDupes(&fList, false);
ui.listWidget->clear();
string tmp;
for (unsigned int i=0; i<iList.size(); i++) {
tmp = iList[i].get_name() + "-" + iList[i].get_fullversion();
ui.listWidget->addItem(new QListWidgetItem(QIcon("/usr/share/mpkg/icons/install.png"), tmp.c_str()));
}
for (unsigned int i=0; i<rList.size(); i++) {
tmp = rList[i].get_name() + "-" + rList[i].get_fullversion();
ui.listWidget->addItem(new QListWidgetItem(QIcon("/usr/share/mpkg/icons/purge.png"), tmp.c_str()));
}
for (unsigned int i=0; i<fList.size(); i++) {
tmp = fList[i].get_name() + "-" + fList[i].get_fullversion();
ui.listWidget->addItem(new QListWidgetItem(QIcon("/usr/share/mpkg/icons/warning.png"), tmp.c_str()));
}
for (unsigned int i=0; i<errorList.size(); i++) {
ui.listWidget->addItem(new QListWidgetItem(QIcon("/usr/share/mpkg/icons/unknown.png"), errorList[i].c_str()));
}
if (iList.size()>0 && errorList.empty() && fList.size()==0) {
ui.continueButton->setEnabled(true);
ui.label->setText(tr("Action summary:"));
}
else ui.label->setText(text);
}
void mpkg::exportBase(string output_dir)
{
say("Exporting data to %s directory\n",output_dir.c_str());
// First of all, clear previous contents
system("rm -rf " + output_dir+"; mkdir -p " + output_dir);
PACKAGE_LIST allPackages;
SQLRecord sqlSearch;
sqlSearch.addField("package_installed", 1);
get_packagelist(&sqlSearch, &allPackages);
say("Received %d packages\n",allPackages.size());
for (int i=0; i<allPackages.size(); i++)
{
say("[%d/%d] Exporting package %s\n",i+1,allPackages.size(),allPackages.get_package(i)->get_name()->c_str());
db->exportPackage(output_dir, allPackages.get_package(i));
}
}
// New, very very fast function. The only one who should be used, if fact
int mpkgSys::requestInstall(vector<string> package_name, vector<string> package_version, vector<string> package_build, mpkgDatabase *db, DependencyTracker *DepTracker, vector<string> *eList) {
// First of all, check for local packages
vector<int> localPackages;
vector<bool> isLocal(package_name.size(), false);
LocalPackage *_p;
string pkgType;
for (size_t i=0; i<package_name.size(); i++) {
pkgType=getExtension(package_name[i]);
if (pkgType=="txz" || pkgType == "tbz" || pkgType == "tlz" || pkgType=="tgz" || pkgType == "spkg") {
if (FileExists(package_name[i])) {
_p = new LocalPackage(package_name[i]);
_p->injectFile();
db->emerge_to_db(&_p->data);
package_name[i] = _p->data.get_name();
package_version[i] = _p->data.get_version();
package_build[i] = _p->data.get_build();
isLocal[i]=true;
//printf("\nDetected local package\nFilename: %s\nName:%s\nVersion:%s\n", _p->data.get_filename().c_str(), _p->data.get_name().c_str(), _p->data.get_version().c_str());
localPackages.push_back(_p->data.get_id());
delete _p;
}
}
}
vector<string> errorList;
//printf("using error list\n");
// Creating DB cache
// 1. Creating a request for all packages which are in package_name vector.
SQLRecord sqlSearch;
sqlSearch.setSearchMode(SEARCH_IN);
for (size_t i=0; i<package_name.size(); i++) {
if (isLocal[i]) {
continue;
}
sqlSearch.addField("package_name", package_name[i]);
}
// 2. Requesting database by search array
PACKAGE_LIST pCache;
//printf("SLOW GET_PACKAGELIST CALL: %s %d\n", __func__, __LINE__);
int query_ret = db->get_packagelist(sqlSearch, &pCache, true, false);
if (query_ret != 0) {
errorList.push_back(mError("Error querying database"));
if (eList) *eList = errorList;
return MPKGERROR_SQLQUERYERROR;
}
// 3. Temporary matrix, temporary list (for each package), and result list
vector<PACKAGE_LIST> tmpMatrix;
PACKAGE_LIST *tmpList=new PACKAGE_LIST;
PACKAGE_LIST resultList;
PACKAGE_LIST uninstallList;
// 4. Search by cache for installed ones, check for availability and select the appropriate versions
// 4.1 Building matrix: one vector per list of packages with same name
for (size_t i=0; i<package_name.size(); i++) {
delete tmpList;
tmpList = new PACKAGE_LIST;
for (size_t t=0; t<pCache.size(); t++) {
if (pCache.at(t).get_name() == package_name[i]) {
if (isLocal[i] && pCache[t].get_id()!=localPackages[i]) continue;
tmpList->add(pCache.at(t));
}
}
tmpMatrix.push_back(*tmpList);
}
//printf("tmpMatrix[0] size = %d\n", tmpMatrix[0].size());
// So, the matrix has been created.
// In case of any error, collect all of them, and return MPKGERROR_IMPOSSIBLE
// Sizes of tmpMatrix and input vectors are the same, so we can use any of them
PACKAGE *outPackage = NULL, *installedOne = NULL;
for (size_t i=0; i<tmpMatrix.size(); i++) {
delete tmpList;
tmpList = new PACKAGE_LIST;
for (size_t t=0; t<tmpMatrix[i].size(); t++) {
// Filling the tmpList with reachable (=installed or available) ones for each package
if (tmpMatrix[i].at(t).available(true) || tmpMatrix[i].at(t).installed()) {
if (package_version[i].empty() || tmpMatrix[i].at(t).get_version() == package_version[i]) {
if (package_build[i].empty() || package_build[i]==tmpMatrix[i].at(t).get_build()) tmpList->add(tmpMatrix[i][t]);
}
}
}
// Now, we have a list of all good candidates. We will filter already installed ones separately for better UI output.
tmpList->initVersioning();
outPackage = tmpList->getMaxVersion();
//if (outPackage) printf("outPackage VERSION: %s\n", outPackage->get_fullversion().c_str());
installedOne = (PACKAGE *) tmpMatrix[i].getInstalledOne();
if (outPackage == NULL) {
string errorText = _("Requested package ") + package_name[i];
if (!package_version[i].empty()) errorText += "-" + package_version[i];
if (!package_build[i].empty()) errorText += "-" + package_build[i];
if (!installedOne) errorList.push_back(mError(errorText + _(" cannot be found")));
else errorList.push_back(mError(errorText + _(" is already installed")));
}
else {
//printf("____________________________CHECK FOR UPDATE, installedOne: %p_____________________________\n", installedOne);
// Check for update
if (installedOne && outPackage->get_id() != installedOne->get_id()) {
// This is update
//printf("added to uninstall: %d\n", installedOne->get_id());
uninstallList.add(*installedOne);
}
resultList.add(*outPackage);
}
}
delete tmpList;
// Special addition for local packages installed using -z key: check for installed one
for (size_t i=0; i<isLocal.size(); ++i) {
if (!isLocal[i]) continue;
for (size_t t=0; t<pCache.size(); ++t) {
if (pCache[t].installed() && pCache[t].get_id()!=localPackages[i] && pCache[t].get_name()==package_name[i]) {
requestUninstall(pCache.get_package_ptr(t), db, DepTracker);
}
}
}
// Now, check resultList for installed ones and unavailable ones
for (size_t i=0; i<resultList.size(); i++) {
if (resultList[i].installed()) {
mWarning(_("Package ") + resultList[i].get_name() + "-" + resultList[i].get_fullversion() + _(" is already installed"));
}
else {
if (!resultList[i].available(true)) {
errorList.push_back(mError(_("Package ") + resultList[i].get_name() + "-" + resultList[i].get_fullversion() + _(" is unavailable")));
}
}
}
// NEW: ignore already installed packages
tmpList = new PACKAGE_LIST;
for (size_t i=0; i<resultList.size(); ++i) {
if (!resultList[i].installed()) {
tmpList->add(resultList[i]);
}
}
resultList = *tmpList;
delete tmpList;
//printf("resultList size = %d\n", resultList.size());
if (errorList.empty()) {
// Push to database
__requestInstallPkgList(&resultList, db, DepTracker);
for (size_t i=0; i<uninstallList.size(); i++) requestUninstall(uninstallList.get_package_ptr(i), db, DepTracker);
}
else {
mError(_("Errors detected, cannot continue"));
if (eList) *eList = errorList;
return MPKGERROR_IMPOSSIBLE;
}
if (eList) *eList = errorList;
return 0;
}
