apt-pkg/upgrade.cc

   1 // Include Files                                                        /*{{{*/
   2 #include <config.h>
   3
   4 #include <apt-pkg/algorithms.h>
   5 #include <apt-pkg/configuration.h>
   6 #include <apt-pkg/edsp.h>
   7 #include <apt-pkg/error.h>
   8 #include <apt-pkg/progress.h>
   9 #include <apt-pkg/upgrade.h>
  10 #include <apt-pkg/depcache.h>
  11 #include <apt-pkg/pkgcache.h>
  12 #include <apt-pkg/cacheiterators.h>
  13
  14 #include <string>
  15
  16 #include <apti18n.h>
  17                                                                         /*}}}*/
  18
  19 // DistUpgrade - Distribution upgrade                                   /*{{{*/
  20 // ---------------------------------------------------------------------
  21 /* This autoinstalls every package and then force installs every
  22    pre-existing package. This creates the initial set of conditions which
  23    most likely contain problems because too many things were installed.
  24
  25    The problem resolver is used to resolve the problems.
  26  */
  27 static bool pkgDistUpgrade(pkgDepCache &Cache, OpProgress * const Progress)
  28 {
  29    std::string const solver = _config->Find("APT::Solver", "internal");
  30    if (solver != "internal")
  31       return EDSP::ResolveExternal(solver.c_str(), Cache, false, true, false, Progress);
  32
  33    if (Progress != NULL)
  34       Progress->OverallProgress(0, 100, 1, _("Calculating upgrade"));
  35
  36    pkgDepCache::ActionGroup group(Cache);
  37
  38    /* Upgrade all installed packages first without autoinst to help the resolver
  39       in versioned or-groups to upgrade the old solver instead of installing
  40       a new one (if the old solver is not the first one [anymore]) */
  41    for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I)
  42       if (I->CurrentVer != 0)
  43          Cache.MarkInstall(I, false, 0, false);
  44
  45    if (Progress != NULL)
  46       Progress->Progress(10);
  47
  48    /* Auto upgrade all installed packages, this provides the basis
  49       for the installation */
  50    for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I)
  51       if (I->CurrentVer != 0)
  52          Cache.MarkInstall(I, true, 0, false);
  53
  54    if (Progress != NULL)
  55       Progress->Progress(50);
  56
  57    /* Now, install each essential package which is not installed
  58       (and not provided by another package in the same name group) */
  59    std::string essential = _config->Find("pkgCacheGen::Essential", "all");
  60    if (essential == "all")
  61    {
  62       for (pkgCache::GrpIterator G = Cache.GrpBegin(); G.end() == false; ++G)
  63       {
  64          bool isEssential = false;
  65          bool instEssential = false;
  66          for (pkgCache::PkgIterator P = G.PackageList(); P.end() == false; P = G.NextPkg(P))
  67          {
  68             if ((P->Flags & pkgCache::Flag::Essential) != pkgCache::Flag::Essential)
  69                continue;
  70             isEssential = true;
  71             if (Cache[P].Install() == true)
  72             {
  73                instEssential = true;
  74                break;
  75             }
  76          }
  77          if (isEssential == false || instEssential == true)
  78             continue;
  79          pkgCache::PkgIterator P = G.FindPreferredPkg();
  80          Cache.MarkInstall(P, true, 0, false);
  81       }
  82    }
  83    else if (essential != "none")
  84       for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I)
  85          if ((I->Flags & pkgCache::Flag::Essential) == pkgCache::Flag::Essential)
  86             Cache.MarkInstall(I, true, 0, false);
  87
  88    if (Progress != NULL)
  89       Progress->Progress(55);
  90
  91    /* We do it again over all previously installed packages to force
  92       conflict resolution on them all. */
  93    for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I)
  94       if (I->CurrentVer != 0)
  95          Cache.MarkInstall(I, false, 0, false);
  96
  97    if (Progress != NULL)
  98       Progress->Progress(65);
  99
 100    pkgProblemResolver Fix(&Cache);
 101
 102    if (Progress != NULL)
 103       Progress->Progress(95);
 104
 105    // Hold back held packages.
 106    if (_config->FindB("APT::Ignore-Hold",false) == false)
 107    {
 108       for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I)
 109       {
 110          if (I->SelectedState == pkgCache::State::Hold)
 111          {
 112             Fix.Protect(I);
 113             Cache.MarkKeep(I, false, false);
 114          }
 115       }
 116    }
 117
 118    bool const success = Fix.Resolve(false, Progress);
 119    if (Progress != NULL)
 120       Progress->Done();
 121    return success;
 122 }
 123 bool pkgDistUpgrade(pkgDepCache &Cache)
 124 {
 125    return pkgDistUpgrade(Cache, NULL);
 126 }
 127                                                                         /*}}}*/
 128 // AllUpgradeNoNewPackages - Upgrade but no removals or new pkgs        /*{{{*/
 129 static bool pkgAllUpgradeNoNewPackages(pkgDepCache &Cache, OpProgress * const Progress)
 130 {
 131    std::string const solver = _config->Find("APT::Solver", "internal");
 132    if (solver != "internal")
 133       return EDSP::ResolveExternal(solver.c_str(), Cache, true, false, false, Progress);
 134
 135    if (Progress != NULL)
 136       Progress->OverallProgress(0, 100, 1, _("Calculating upgrade"));
 137
 138    pkgDepCache::ActionGroup group(Cache);
 139    pkgProblemResolver Fix(&Cache);
 140
 141    // Upgrade all installed packages
 142    for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I)
 143    {
 144       if (Cache[I].Install() == true)
 145          Fix.Protect(I);
 146
 147       if (_config->FindB("APT::Ignore-Hold",false) == false)
 148          if (I->SelectedState == pkgCache::State::Hold)
 149             continue;
 150
 151       if (I->CurrentVer != 0 && Cache[I].InstallVer != 0)
 152          Cache.MarkInstall(I, false, 0, false);
 153    }
 154
 155    if (Progress != NULL)
 156       Progress->Progress(50);
 157
 158    // resolve remaining issues via keep
 159    bool const success = Fix.ResolveByKeep(Progress);
 160    if (Progress != NULL)
 161       Progress->Done();
 162    return success;
 163 }
 164                                                                         /*}}}*/
 165 // AllUpgradeWithNewInstalls - Upgrade + install new packages as needed /*{{{*/
 166 // ---------------------------------------------------------------------
 167 /* Right now the system must be consistent before this can be called.
 168  * Upgrade as much as possible without deleting anything (useful for
 169  * stable systems)
 170  */
 171 static bool pkgAllUpgradeWithNewPackages(pkgDepCache &Cache, OpProgress * const Progress)
 172 {
 173    std::string const solver = _config->Find("APT::Solver", "internal");
 174    if (solver != "internal")
 175       return EDSP::ResolveExternal(solver.c_str(), Cache, true, false, false, Progress);
 176
 177    if (Progress != NULL)
 178       Progress->OverallProgress(0, 100, 1, _("Calculating upgrade"));
 179
 180    pkgDepCache::ActionGroup group(Cache);
 181    pkgProblemResolver Fix(&Cache);
 182
 183    // provide the initial set of stuff we want to upgrade by marking
 184    // all upgradable packages for upgrade
 185    for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I)
 186    {
 187       if (I->CurrentVer != 0 && Cache[I].InstallVer != 0)
 188       {
 189          if (_config->FindB("APT::Ignore-Hold",false) == false)
 190             if (I->SelectedState == pkgCache::State::Hold)
 191                continue;
 192
 193          Cache.MarkInstall(I, false, 0, false);
 194       }
 195    }
 196
 197    if (Progress != NULL)
 198       Progress->Progress(10);
 199
 200    // then let auto-install loose
 201    for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I)
 202       if (Cache[I].Install())
 203          Cache.MarkInstall(I, true, 0, false);
 204
 205    if (Progress != NULL)
 206       Progress->Progress(50);
 207
 208    // ... but it may remove stuff, we we need to clean up afterwards again
 209    for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I)
 210       if (Cache[I].Delete() == true)
 211          Cache.MarkKeep(I, false, false);
 212
 213    if (Progress != NULL)
 214       Progress->Progress(60);
 215
 216    // resolve remaining issues via keep
 217    bool const success = Fix.ResolveByKeep(Progress);
 218    if (Progress != NULL)
 219       Progress->Done();
 220    return success;
 221 }
 222                                                                         /*}}}*/
 223 // AllUpgrade - Upgrade as many packages as possible                    /*{{{*/
 224 // ---------------------------------------------------------------------
 225 /* Right now the system must be consistent before this can be called.
 226    It also will not change packages marked for install, it only tries
 227    to install packages not marked for install */
 228 static bool pkgAllUpgrade(pkgDepCache &Cache, OpProgress * const Progress)
 229 {
 230    return pkgAllUpgradeNoNewPackages(Cache, Progress);
 231 }
 232 bool pkgAllUpgrade(pkgDepCache &Cache)
 233 {
 234    return pkgAllUpgrade(Cache, NULL);
 235 }
 236                                                                         /*}}}*/
 237 // MinimizeUpgrade - Minimizes the set of packages to be upgraded       /*{{{*/
 238 // ---------------------------------------------------------------------
 239 /* This simply goes over the entire set of packages and tries to keep
 240    each package marked for upgrade. If a conflict is generated then
 241    the package is restored. */
 242 bool pkgMinimizeUpgrade(pkgDepCache &Cache)
 243 {
 244    pkgDepCache::ActionGroup group(Cache);
 245
 246    if (Cache.BrokenCount() != 0)
 247       return false;
 248
 249    // We loop for 10 tries to get the minimal set size.
 250    bool Change = false;
 251    unsigned int Count = 0;
 252    do
 253    {
 254       Change = false;
 255       for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I)
 256       {
 257          // Not interesting
 258          if (Cache[I].Upgrade() == false || Cache[I].NewInstall() == true)
 259             continue;
 260
 261          // Keep it and see if that is OK
 262          Cache.MarkKeep(I, false, false);
 263          if (Cache.BrokenCount() != 0)
 264             Cache.MarkInstall(I, false, 0, false);
 265          else
 266          {
 267             // If keep didn't actually do anything then there was no change..
 268             if (Cache[I].Upgrade() == false)
 269                Change = true;
 270          }
 271       }
 272       ++Count;
 273    }
 274    while (Change == true && Count < 10);
 275
 276    if (Cache.BrokenCount() != 0)
 277       return _error->Error("Internal Error in pkgMinimizeUpgrade");
 278
 279    return true;
 280 }
 281                                                                         /*}}}*/
 282 // APT::Upgrade::Upgrade - Upgrade using a specific strategy            /*{{{*/
 283 bool APT::Upgrade::Upgrade(pkgDepCache &Cache, int mode, OpProgress * const Progress)
 284 {
 285 APT_IGNORE_DEPRECATED_PUSH
 286    if (mode == ALLOW_EVERYTHING)
 287       return pkgDistUpgrade(Cache, Progress);
 288    else if ((mode & ~FORBID_REMOVE_PACKAGES) == 0)
 289       return pkgAllUpgradeWithNewPackages(Cache, Progress);
 290    else if ((mode & ~(FORBID_REMOVE_PACKAGES|FORBID_INSTALL_NEW_PACKAGES)) == 0)
 291       return pkgAllUpgradeNoNewPackages(Cache, Progress);
 292    else
 293       _error->Error("pkgAllUpgrade called with unsupported mode %i", mode);
 294 APT_IGNORE_DEPRECATED_POP
 295    return false;
 296 }
 297                                                                         /*}}}*/