merge sources.list lines based on Release filename

[apt.git] / apt-pkg / upgrade.cc

diff --git a/apt-pkg/upgrade.cc b/apt-pkg/upgrade.cc
index f06f6d40d60cb6b76475ffe6fedec9d42a449f7f..afc9ad613ca0920320ae829eadcff8ee663d4854 100644 (file)
--- a/apt-pkg/upgrade.cc
+++ b/apt-pkg/upgrade.cc
@@ -1,24 +1,17 @@
-

 // Include Files                                                       /*{{{*/
 #include <config.h>
 
 #include <apt-pkg/algorithms.h>
 // Include Files                                                       /*{{{*/
 #include <config.h>
 
 #include <apt-pkg/algorithms.h>

-#include <apt-pkg/upgrade.h>
-#include <apt-pkg/error.h>

 #include <apt-pkg/configuration.h>
 #include <apt-pkg/configuration.h>

-#include <apt-pkg/version.h>
-#include <apt-pkg/sptr.h>
-#include <apt-pkg/acquire-item.h>

 #include <apt-pkg/edsp.h>
 #include <apt-pkg/edsp.h>

-#include <apt-pkg/sourcelist.h>
-#include <apt-pkg/fileutl.h>
+#include <apt-pkg/error.h>

 #include <apt-pkg/progress.h>
 #include <apt-pkg/progress.h>

+#include <apt-pkg/upgrade.h>
+#include <apt-pkg/depcache.h>
+#include <apt-pkg/pkgcache.h>
+#include <apt-pkg/cacheiterators.h>

 
 

-#include <sys/types.h>
-#include <cstdlib>
-#include <algorithm>
-#include <iostream>
-#include <stdio.h>
+#include <string>

 
 #include <apti18n.h>
                                                                        /*}}}*/
 
 #include <apti18n.h>
                                                                        /*}}}*/


@@ -31,13 +24,15 @@
    
    The problem resolver is used to resolve the problems.
  */
    
    The problem resolver is used to resolve the problems.
  */

-bool pkgDistUpgrade(pkgDepCache &Cache)
+static bool pkgDistUpgrade(pkgDepCache &Cache, OpProgress * const Progress)

 {
    std::string const solver = _config->Find("APT::Solver", "internal");
 {
    std::string const solver = _config->Find("APT::Solver", "internal");

-   if (solver != "internal") {
-      OpTextProgress Prog(*_config);
-      return EDSP::ResolveExternal(solver.c_str(), Cache, false, true, false, &Prog);
-   }
+   auto const ret = EDSP::ResolveExternal(solver.c_str(), Cache, EDSP::Request::UPGRADE_ALL, Progress);
+   if (solver != "internal")
+      return ret;
+
+   if (Progress != NULL)
+      Progress->OverallProgress(0, 100, 1, _("Calculating upgrade"));

 
    pkgDepCache::ActionGroup group(Cache);
 
 
    pkgDepCache::ActionGroup group(Cache);
 


@@ -48,12 +43,18 @@ bool pkgDistUpgrade(pkgDepCache &Cache)
       if (I->CurrentVer != 0)
         Cache.MarkInstall(I, false, 0, false);
 
       if (I->CurrentVer != 0)
         Cache.MarkInstall(I, false, 0, false);
 

+   if (Progress != NULL)
+      Progress->Progress(10);
+

    /* Auto upgrade all installed packages, this provides the basis 
       for the installation */
    for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I)
       if (I->CurrentVer != 0)
         Cache.MarkInstall(I, true, 0, false);
 
    /* Auto upgrade all installed packages, this provides the basis 
       for the installation */
    for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I)
       if (I->CurrentVer != 0)
         Cache.MarkInstall(I, true, 0, false);
 

+   if (Progress != NULL)
+      Progress->Progress(50);
+

    /* Now, install each essential package which is not installed
       (and not provided by another package in the same name group) */
    std::string essential = _config->Find("pkgCacheGen::Essential", "all");
    /* Now, install each essential package which is not installed
       (and not provided by another package in the same name group) */
    std::string essential = _config->Find("pkgCacheGen::Essential", "all");


@@ -84,15 +85,24 @@ bool pkgDistUpgrade(pkgDepCache &Cache)
       for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I)
         if ((I->Flags & pkgCache::Flag::Essential) == pkgCache::Flag::Essential)
            Cache.MarkInstall(I, true, 0, false);
       for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I)
         if ((I->Flags & pkgCache::Flag::Essential) == pkgCache::Flag::Essential)
            Cache.MarkInstall(I, true, 0, false);

-   
+
+   if (Progress != NULL)
+      Progress->Progress(55);
+

    /* We do it again over all previously installed packages to force 
       conflict resolution on them all. */
    for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I)
       if (I->CurrentVer != 0)
         Cache.MarkInstall(I, false, 0, false);
 
    /* We do it again over all previously installed packages to force 
       conflict resolution on them all. */
    for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I)
       if (I->CurrentVer != 0)
         Cache.MarkInstall(I, false, 0, false);
 

+   if (Progress != NULL)
+      Progress->Progress(65);
+

    pkgProblemResolver Fix(&Cache);
 
    pkgProblemResolver Fix(&Cache);
 

+   if (Progress != NULL)
+      Progress->Progress(95);
+

    // Hold back held packages.
    if (_config->FindB("APT::Ignore-Hold",false) == false)
    {
    // Hold back held packages.
    if (_config->FindB("APT::Ignore-Hold",false) == false)
    {


@@ -105,26 +115,32 @@ bool pkgDistUpgrade(pkgDepCache &Cache)
         }
       }
    }
         }
       }
    }

-   
-   return Fix.Resolve();
+
+   bool const success = Fix.ResolveInternal(false);
+   if (Progress != NULL)
+      Progress->Done();
+   return success;
+}
+bool pkgDistUpgrade(pkgDepCache &Cache)
+{
+   return pkgDistUpgrade(Cache, NULL);

 }
                                                                        /*}}}*/
 // AllUpgradeNoNewPackages - Upgrade but no removals or new pkgs        /*{{{*/
 }
                                                                        /*}}}*/
 // AllUpgradeNoNewPackages - Upgrade but no removals or new pkgs        /*{{{*/

-static bool pkgAllUpgradeNoNewPackages(pkgDepCache &Cache)
+static bool pkgAllUpgradeNoNewPackages(pkgDepCache &Cache, OpProgress * const Progress)

 {
    std::string const solver = _config->Find("APT::Solver", "internal");
 {
    std::string const solver = _config->Find("APT::Solver", "internal");

-   if (solver != "internal") {
-      OpTextProgress Prog(*_config);
-      return EDSP::ResolveExternal(solver.c_str(), Cache, true, false, false, &Prog);
-   }
+   constexpr auto flags = EDSP::Request::UPGRADE_ALL | EDSP::Request::FORBID_NEW_INSTALL | EDSP::Request::FORBID_REMOVE;
+   auto const ret = EDSP::ResolveExternal(solver.c_str(), Cache, flags, Progress);
+   if (solver != "internal")
+      return ret;

 
 

-   pkgDepCache::ActionGroup group(Cache);
+   if (Progress != NULL)
+      Progress->OverallProgress(0, 100, 1, _("Calculating upgrade"));

 
 

+   pkgDepCache::ActionGroup group(Cache);

    pkgProblemResolver Fix(&Cache);
 
    pkgProblemResolver Fix(&Cache);
 

-   if (Cache.BrokenCount() != 0)
-      return false;
-   

    // Upgrade all installed packages
    for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I)
    {
    // Upgrade all installed packages
    for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I)
    {


@@ -138,8 +154,15 @@ static bool pkgAllUpgradeNoNewPackages(pkgDepCache &Cache)
       if (I->CurrentVer != 0 && Cache[I].InstallVer != 0)
         Cache.MarkInstall(I, false, 0, false);
    }
       if (I->CurrentVer != 0 && Cache[I].InstallVer != 0)
         Cache.MarkInstall(I, false, 0, false);
    }

-      
-   return Fix.ResolveByKeep();
+
+   if (Progress != NULL)
+      Progress->Progress(50);
+
+   // resolve remaining issues via keep
+   bool const success = Fix.ResolveByKeepInternal();
+   if (Progress != NULL)
+      Progress->Done();
+   return success;

 }
                                                                        /*}}}*/
 // AllUpgradeWithNewInstalls - Upgrade + install new packages as needed /*{{{*/
 }
                                                                        /*}}}*/
 // AllUpgradeWithNewInstalls - Upgrade + install new packages as needed /*{{{*/


@@ -148,14 +171,19 @@ static bool pkgAllUpgradeNoNewPackages(pkgDepCache &Cache)
  * Upgrade as much as possible without deleting anything (useful for
  * stable systems)
  */
  * Upgrade as much as possible without deleting anything (useful for
  * stable systems)
  */

-static bool pkgAllUpgradeWithNewPackages(pkgDepCache &Cache)
+static bool pkgAllUpgradeWithNewPackages(pkgDepCache &Cache, OpProgress * const Progress)

 {
 {

-   pkgDepCache::ActionGroup group(Cache);
+   std::string const solver = _config->Find("APT::Solver", "internal");
+   constexpr auto flags = EDSP::Request::UPGRADE_ALL | EDSP::Request::FORBID_REMOVE;
+   auto const ret = EDSP::ResolveExternal(solver.c_str(), Cache, flags, Progress);
+   if (solver != "internal")
+      return ret;

 
 

-   pkgProblemResolver Fix(&Cache);
+   if (Progress != NULL)
+      Progress->OverallProgress(0, 100, 1, _("Calculating upgrade"));

 
 

-   if (Cache.BrokenCount() != 0)
-      return false;
+   pkgDepCache::ActionGroup group(Cache);
+   pkgProblemResolver Fix(&Cache);

 
    // provide the initial set of stuff we want to upgrade by marking
    // all upgradable packages for upgrade
 
    // provide the initial set of stuff we want to upgrade by marking
    // all upgradable packages for upgrade


@@ -171,18 +199,30 @@ static bool pkgAllUpgradeWithNewPackages(pkgDepCache &Cache)
       }
    }
 
       }
    }
 

+   if (Progress != NULL)
+      Progress->Progress(10);
+

    // then let auto-install loose
    for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I)
       if (Cache[I].Install())
         Cache.MarkInstall(I, true, 0, false);
 
    // then let auto-install loose
    for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I)
       if (Cache[I].Install())
         Cache.MarkInstall(I, true, 0, false);
 

+   if (Progress != NULL)
+      Progress->Progress(50);
+

    // ... but it may remove stuff, we we need to clean up afterwards again
    for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I)
       if (Cache[I].Delete() == true)
         Cache.MarkKeep(I, false, false);
 
    // ... but it may remove stuff, we we need to clean up afterwards again
    for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I)
       if (Cache[I].Delete() == true)
         Cache.MarkKeep(I, false, false);
 

+   if (Progress != NULL)
+      Progress->Progress(60);
+

    // resolve remaining issues via keep
    // resolve remaining issues via keep

-   return Fix.ResolveByKeep();
+   bool const success = Fix.ResolveByKeepInternal();
+   if (Progress != NULL)
+      Progress->Done();
+   return success;

 }
                                                                        /*}}}*/
 // AllUpgrade - Upgrade as many packages as possible                   /*{{{*/
 }
                                                                        /*}}}*/
 // AllUpgrade - Upgrade as many packages as possible                   /*{{{*/


@@ -190,9 +230,13 @@ static bool pkgAllUpgradeWithNewPackages(pkgDepCache &Cache)
 /* Right now the system must be consistent before this can be called.
    It also will not change packages marked for install, it only tries
    to install packages not marked for install */
 /* Right now the system must be consistent before this can be called.
    It also will not change packages marked for install, it only tries
    to install packages not marked for install */

+static bool pkgAllUpgrade(pkgDepCache &Cache, OpProgress * const Progress)
+{
+   return pkgAllUpgradeNoNewPackages(Cache, Progress);
+}

 bool pkgAllUpgrade(pkgDepCache &Cache)
 {
 bool pkgAllUpgrade(pkgDepCache &Cache)
 {

-   return pkgAllUpgradeNoNewPackages(Cache);
+   return pkgAllUpgrade(Cache, NULL);

 }
                                                                        /*}}}*/
 // MinimizeUpgrade - Minimizes the set of packages to be upgraded      /*{{{*/
 }
                                                                        /*}}}*/
 // MinimizeUpgrade - Minimizes the set of packages to be upgraded      /*{{{*/


@@ -225,7 +269,7 @@ bool pkgMinimizeUpgrade(pkgDepCache &Cache)
            Cache.MarkInstall(I, false, 0, false);
         else
         {
            Cache.MarkInstall(I, false, 0, false);
         else
         {

-           // If keep didnt actually do anything then there was no change..
+           // If keep didn't actually do anything then there was no change..

            if (Cache[I].Upgrade() == false)
               Change = true;
         }       
            if (Cache[I].Upgrade() == false)
               Change = true;
         }       


@@ -240,24 +284,19 @@ bool pkgMinimizeUpgrade(pkgDepCache &Cache)
    return true;
 }
                                                                        /*}}}*/
    return true;
 }
                                                                        /*}}}*/

-// APT::Upgrade::Upgrade - Upgrade using a specific strategy           /*{{{*/
-bool APT::Upgrade::Upgrade(pkgDepCache &Cache, int mode)
+// APT::Upgrade::Upgrade - Upgrade using a specific strategy           /*{{{*/
+bool APT::Upgrade::Upgrade(pkgDepCache &Cache, int mode, OpProgress * const Progress)

 {
 {

-   if (mode == 0) 
-   {
-      return pkgDistUpgrade(Cache);
-   }
+APT_IGNORE_DEPRECATED_PUSH
+   if (mode == ALLOW_EVERYTHING)
+      return pkgDistUpgrade(Cache, Progress);

    else if ((mode & ~FORBID_REMOVE_PACKAGES) == 0)
    else if ((mode & ~FORBID_REMOVE_PACKAGES) == 0)

-   {
-      return pkgAllUpgradeWithNewPackages(Cache);
-   } 
+      return pkgAllUpgradeWithNewPackages(Cache, Progress);

    else if ((mode & ~(FORBID_REMOVE_PACKAGES|FORBID_INSTALL_NEW_PACKAGES)) == 0)
    else if ((mode & ~(FORBID_REMOVE_PACKAGES|FORBID_INSTALL_NEW_PACKAGES)) == 0)

-   {
-      return pkgAllUpgradeNoNewPackages(Cache);
-   }
+      return pkgAllUpgradeNoNewPackages(Cache, Progress);

    else
       _error->Error("pkgAllUpgrade called with unsupported mode %i", mode);
    else
       _error->Error("pkgAllUpgrade called with unsupported mode %i", mode);

-
+APT_IGNORE_DEPRECATED_POP

    return false;
 }
                                                                        /*}}}*/
    return false;
 }
                                                                        /*}}}*/