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

// Include Files							/*{{{*/
#include <config.h>

#include <apt-pkg/algorithms.h>
#include <apt-pkg/configuration.h>
#include <apt-pkg/edsp.h>
#include <apt-pkg/error.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 <string>

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

// DistUpgrade - Distribution upgrade					/*{{{*/
// ---------------------------------------------------------------------
/* This autoinstalls every package and then force installs every 
   pre-existing package. This creates the initial set of conditions which 
   most likely contain problems because too many things were installed.
   
   The problem resolver is used to resolve the problems.
 */
bool pkgDistUpgrade(pkgDepCache &Cache, OpProgress * const Progress)
{
   std::string const solver = _config->Find("APT::Solver", "internal");
   if (solver != "internal")
      return EDSP::ResolveExternal(solver.c_str(), Cache, false, true, false, Progress);

   if (Progress != NULL)
      Progress->OverallProgress(0, 100, 1, _("Calculating upgrade"));

   pkgDepCache::ActionGroup group(Cache);

   /* Upgrade all installed packages first without autoinst to help the resolver
      in versioned or-groups to upgrade the old solver instead of installing
      a new one (if the old solver is not the first one [anymore]) */
   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(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);

   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");
   if (essential == "all")
   {
      for (pkgCache::GrpIterator G = Cache.GrpBegin(); G.end() == false; ++G)
      {
	 bool isEssential = false;
	 bool instEssential = false;
	 for (pkgCache::PkgIterator P = G.PackageList(); P.end() == false; P = G.NextPkg(P))
	 {
	    if ((P->Flags & pkgCache::Flag::Essential) != pkgCache::Flag::Essential)
	       continue;
	    isEssential = true;
	    if (Cache[P].Install() == true)
	    {
	       instEssential = true;
	       break;
	    }
	 }
	 if (isEssential == false || instEssential == true)
	    continue;
	 pkgCache::PkgIterator P = G.FindPreferredPkg();
	 Cache.MarkInstall(P, true, 0, false);
      }
   }
   else if (essential != "none")
      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);

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

   pkgProblemResolver Fix(&Cache);

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

   // Hold back held packages.
   if (_config->FindB("APT::Ignore-Hold",false) == false)
   {
      for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I)
      {
	 if (I->SelectedState == pkgCache::State::Hold)
	 {
	    Fix.Protect(I);
	    Cache.MarkKeep(I, false, false);
	 }
      }
   }

   bool const success = Fix.Resolve(false, Progress);
   if (Progress != NULL)
      Progress->Done();
   return success;
}
									/*}}}*/
// AllUpgradeNoNewPackages - Upgrade but no removals or new pkgs        /*{{{*/
static bool pkgAllUpgradeNoNewPackages(pkgDepCache &Cache, OpProgress * const Progress)
{
   std::string const solver = _config->Find("APT::Solver", "internal");
   if (solver != "internal")
      return EDSP::ResolveExternal(solver.c_str(), Cache, true, false, false, Progress);

   if (Progress != NULL)
      Progress->OverallProgress(0, 100, 1, _("Calculating upgrade"));

   pkgDepCache::ActionGroup group(Cache);

   pkgProblemResolver Fix(&Cache);

   if (Cache.BrokenCount() != 0)
      return false;
   
   // Upgrade all installed packages
   for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I)
   {
      if (Cache[I].Install() == true)
	 Fix.Protect(I);
	  
      if (_config->FindB("APT::Ignore-Hold",false) == false)
	 if (I->SelectedState == pkgCache::State::Hold)
	    continue;
      
      if (I->CurrentVer != 0 && Cache[I].InstallVer != 0)
	 Cache.MarkInstall(I, false, 0, false);
   }

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

   // resolve remaining issues via keep
   bool const success = Fix.ResolveByKeep(Progress);
   if (Progress != NULL)
      Progress->Done();
   return success;
}
									/*}}}*/
// AllUpgradeWithNewInstalls - Upgrade + install new packages as needed /*{{{*/
// ---------------------------------------------------------------------
/* Right now the system must be consistent before this can be called.
 * Upgrade as much as possible without deleting anything (useful for
 * stable systems)
 */
static bool pkgAllUpgradeWithNewPackages(pkgDepCache &Cache, OpProgress * const Progress)
{
   std::string const solver = _config->Find("APT::Solver", "internal");
   if (solver != "internal")
      return EDSP::ResolveExternal(solver.c_str(), Cache, true, false, false, Progress);

   if (Progress != NULL)
      Progress->OverallProgress(0, 100, 1, _("Calculating upgrade"));

   pkgDepCache::ActionGroup group(Cache);

   pkgProblemResolver Fix(&Cache);

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

   // provide the initial set of stuff we want to upgrade by marking
   // all upgradable packages for upgrade
   for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I)
   {
      if (I->CurrentVer != 0 && Cache[I].InstallVer != 0)
      {
         if (_config->FindB("APT::Ignore-Hold",false) == false)
            if (I->SelectedState == pkgCache::State::Hold)
               continue;

	 Cache.MarkInstall(I, false, 0, false);
      }
   }

   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);

   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);

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

   // resolve remaining issues via keep
   bool const success = Fix.ResolveByKeep(Progress);
   if (Progress != NULL)
      Progress->Done();
   return success;
}
									/*}}}*/
// AllUpgrade - Upgrade as many packages as possible			/*{{{*/
// ---------------------------------------------------------------------
/* 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 */
bool pkgAllUpgrade(pkgDepCache &Cache, OpProgress * const Progress)
{
   return pkgAllUpgradeNoNewPackages(Cache, Progress);
}
									/*}}}*/
// MinimizeUpgrade - Minimizes the set of packages to be upgraded	/*{{{*/
// ---------------------------------------------------------------------
/* This simply goes over the entire set of packages and tries to keep 
   each package marked for upgrade. If a conflict is generated then 
   the package is restored. */
bool pkgMinimizeUpgrade(pkgDepCache &Cache)
{   
   pkgDepCache::ActionGroup group(Cache);

   if (Cache.BrokenCount() != 0)
      return false;
   
   // We loop for 10 tries to get the minimal set size.
   bool Change = false;
   unsigned int Count = 0;
   do
   {
      Change = false;
      for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I)
      {
	 // Not interesting
	 if (Cache[I].Upgrade() == false || Cache[I].NewInstall() == true)
	    continue;

	 // Keep it and see if that is OK
	 Cache.MarkKeep(I, false, false);
	 if (Cache.BrokenCount() != 0)
	    Cache.MarkInstall(I, false, 0, false);
	 else
	 {
	    // If keep didn't actually do anything then there was no change..
	    if (Cache[I].Upgrade() == false)
	       Change = true;
	 }	 
      }      
      ++Count;
   }
   while (Change == true && Count < 10);

   if (Cache.BrokenCount() != 0)
      return _error->Error("Internal Error in pkgMinimizeUpgrade");
   
   return true;
}
									/*}}}*/
// APT::Upgrade::Upgrade - Upgrade using a specific strategy		/*{{{*/
bool APT::Upgrade::Upgrade(pkgDepCache &Cache, int mode, OpProgress * const Progress)
{
APT_IGNORE_DEPRECATED_PUSH
   if (mode == ALLOW_EVERYTHING)
      return pkgDistUpgrade(Cache, Progress);
   else if ((mode & ~FORBID_REMOVE_PACKAGES) == 0)
      return pkgAllUpgradeWithNewPackages(Cache, Progress);
   else if ((mode & ~(FORBID_REMOVE_PACKAGES|FORBID_INSTALL_NEW_PACKAGES)) == 0)
      return pkgAllUpgradeNoNewPackages(Cache, Progress);
   else
      _error->Error("pkgAllUpgrade called with unsupported mode %i", mode);
APT_IGNORE_DEPRECATED_POP
   return false;
}
									/*}}}*/
Commit	Line	Data
82e369c4 MV	1	// Include Files /{{{/
	2	#include <config.h>
	3
	4	#include <apt-pkg/algorithms.h>
82e369c4	5	#include <apt-pkg/configuration.h>
82e369c4	6	#include <apt-pkg/edsp.h>
453b82a3	7	#include <apt-pkg/error.h>
82e369c4	8	#include <apt-pkg/progress.h>
453b82a3 DK	9	#include <apt-pkg/upgrade.h>
	10	#include <apt-pkg/depcache.h>
	11	#include <apt-pkg/pkgcache.h>
	12	#include <apt-pkg/cacheiterators.h>
82e369c4	13
453b82a3	14	#include <string>
82e369c4 MV	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	*/
2a884c61	27	bool pkgDistUpgrade(pkgDepCache &Cache, OpProgress * const Progress)
82e369c4 MV	28	{
82e369c4 MV	29	std::string const solver = _config->Find("APT::Solver", "internal");
2a884c61 DK	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"));
82e369c4 MV	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
2a884c61 DK	45	if (Progress != NULL)
	46	Progress->Progress(10);
	47
82e369c4 MV	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
2a884c61 DK	54	if (Progress != NULL)
	55	Progress->Progress(50);
	56
82e369c4 MV	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);
2a884c61 DK	87
	88	if (Progress != NULL)
	89	Progress->Progress(55);
	90
82e369c4 MV	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
2a884c61 DK	97	if (Progress != NULL)
	98	Progress->Progress(65);
	99
82e369c4 MV	100	pkgProblemResolver Fix(&Cache);
82e369c4 MV	101
2a884c61 DK	102	if (Progress != NULL)
	103	Progress->Progress(95);
	104
82e369c4 MV	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	}
2a884c61 DK	117
	118	bool const success = Fix.Resolve(false, Progress);
	119	if (Progress != NULL)
	120	Progress->Done();
	121	return success;
82e369c4 MV	122	}
	123	/}}}/
	124	// AllUpgradeNoNewPackages - Upgrade but no removals or new pkgs /{{{/
2a884c61	125	static bool pkgAllUpgradeNoNewPackages(pkgDepCache &Cache, OpProgress * const Progress)
82e369c4 MV	126	{
82e369c4 MV	127	std::string const solver = _config->Find("APT::Solver", "internal");
2a884c61 DK	128	if (solver != "internal")
	129	return EDSP::ResolveExternal(solver.c_str(), Cache, true, false, false, Progress);
	130
	131	if (Progress != NULL)
	132	Progress->OverallProgress(0, 100, 1, _("Calculating upgrade"));
82e369c4 MV	133
	134	pkgDepCache::ActionGroup group(Cache);
	135
	136	pkgProblemResolver Fix(&Cache);
	137
	138	if (Cache.BrokenCount() != 0)
	139	return false;
	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	}
2a884c61 DK	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;
82e369c4 MV	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	*/
2a884c61	171	static bool pkgAllUpgradeWithNewPackages(pkgDepCache &Cache, OpProgress * const Progress)
82e369c4	172	{
172947cd	173	std::string const solver = _config->Find("APT::Solver", "internal");
2a884c61 DK	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"));
172947cd	179
82e369c4 MV	180	pkgDepCache::ActionGroup group(Cache);
	181
	182	pkgProblemResolver Fix(&Cache);
	183
	184	if (Cache.BrokenCount() != 0)
	185	return false;
	186
	187	// provide the initial set of stuff we want to upgrade by marking
	188	// all upgradable packages for upgrade
	189	for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I)
	190	{
	191	if (I->CurrentVer != 0 && Cache[I].InstallVer != 0)
	192	{
	193	if (_config->FindB("APT::Ignore-Hold",false) == false)
	194	if (I->SelectedState == pkgCache::State::Hold)
	195	continue;
	196
	197	Cache.MarkInstall(I, false, 0, false);
	198	}
	199	}
	200
2a884c61 DK	201	if (Progress != NULL)
	202	Progress->Progress(10);
	203
82e369c4 MV	204	// then let auto-install loose
	205	for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I)
	206	if (Cache[I].Install())
	207	Cache.MarkInstall(I, true, 0, false);
	208
2a884c61 DK	209	if (Progress != NULL)
	210	Progress->Progress(50);
	211
82e369c4 MV	212	// ... but it may remove stuff, we we need to clean up afterwards again
	213	for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I)
	214	if (Cache[I].Delete() == true)
	215	Cache.MarkKeep(I, false, false);
	216
2a884c61 DK	217	if (Progress != NULL)
	218	Progress->Progress(60);
	219
82e369c4	220	// resolve remaining issues via keep
2a884c61 DK	221	bool const success = Fix.ResolveByKeep(Progress);
	222	if (Progress != NULL)
	223	Progress->Done();
	224	return success;
82e369c4 MV	225	}
	226	/}}}/
	227	// AllUpgrade - Upgrade as many packages as possible /{{{/
	228	// ---------------------------------------------------------------------
	229	/* Right now the system must be consistent before this can be called.
	230	It also will not change packages marked for install, it only tries
	231	to install packages not marked for install */
2a884c61	232	bool pkgAllUpgrade(pkgDepCache &Cache, OpProgress * const Progress)
82e369c4	233	{
2a884c61	234	return pkgAllUpgradeNoNewPackages(Cache, Progress);
82e369c4 MV	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	{
1e3f4083	267	// If keep didn't actually do anything then there was no change..
82e369c4 MV	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	/}}}/
2a884c61 DK	282	// APT::Upgrade::Upgrade - Upgrade using a specific strategy /{{{/
2a884c61 DK	283	bool APT::Upgrade::Upgrade(pkgDepCache &Cache, int mode, OpProgress * const Progress)
82e369c4	284	{
586d8704	285	APT_IGNORE_DEPRECATED_PUSH
67caa2e6	286	if (mode == ALLOW_EVERYTHING)
2a884c61	287	return pkgDistUpgrade(Cache, Progress);
82e369c4	288	else if ((mode & ~FORBID_REMOVE_PACKAGES) == 0)
2a884c61	289	return pkgAllUpgradeWithNewPackages(Cache, Progress);
3f506f68	290	else if ((mode & ~(FORBID_REMOVE_PACKAGES\|FORBID_INSTALL_NEW_PACKAGES)) == 0)
2a884c61	291	return pkgAllUpgradeNoNewPackages(Cache, Progress);
82e369c4 MV	292	else
82e369c4 MV	293	_error->Error("pkgAllUpgrade called with unsupported mode %i", mode);
586d8704	294	APT_IGNORE_DEPRECATED_POP
82e369c4 MV	295	return false;
	296	}
	297	/}}}/