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

// -*- mode: cpp; mode: fold -*-
// Description								/*{{{*/
// $Id: packagemanager.cc,v 1.15 1999/07/03 03:10:35 jgg Exp $
/* ######################################################################

   Package Manager - Abstacts the package manager

   More work is needed in the area of transitioning provides, ie exim
   replacing smail. This can cause interesing side effects.

   Other cases involving conflicts+replaces should be tested. 
   
   ##################################################################### */
									/*}}}*/
// Include Files							/*{{{*/
#ifdef __GNUG__
#pragma implementation "apt-pkg/packagemanager.h"
#endif
#include <apt-pkg/packagemanager.h>
#include <apt-pkg/orderlist.h>
#include <apt-pkg/depcache.h>
#include <apt-pkg/error.h>
#include <apt-pkg/version.h>
#include <apt-pkg/acquire-item.h>
#include <apt-pkg/algorithms.h>
#include <apt-pkg/configuration.h>
									/*}}}*/

// PM::PackageManager - Constructor					/*{{{*/
// ---------------------------------------------------------------------
/* */
pkgPackageManager::pkgPackageManager(pkgDepCache &Cache) : Cache(Cache)
{
   FileNames = new string[Cache.Head().PackageCount];
   List = 0;
   Debug = _config->FindB("Debug::pkgPackageManager",false);
}
									/*}}}*/
// PM::PackageManager - Destructor					/*{{{*/
// ---------------------------------------------------------------------
/* */
pkgPackageManager::~pkgPackageManager()
{
   delete List;
   delete [] FileNames;
}
									/*}}}*/
// PM::GetArchives - Queue the archives for download			/*{{{*/
// ---------------------------------------------------------------------
/* */
bool pkgPackageManager::GetArchives(pkgAcquire *Owner,pkgSourceList *Sources,
				    pkgRecords *Recs)
{
   if (CreateOrderList() == false)
      return false;
   
   if (List->OrderUnpack() == false)
      return _error->Error("Internal ordering error");

   for (pkgOrderList::iterator I = List->begin(); I != List->end(); I++)
   {
      PkgIterator Pkg(Cache,*I);
      FileNames[Pkg->ID] = string();
      
      // Skip packages to erase
      if (Cache[Pkg].Delete() == true)
	 continue;

      // Skip Packages that need configure only.
      if (Pkg.State() == pkgCache::PkgIterator::NeedsConfigure && 
	  Cache[Pkg].Keep() == true)
	 continue;

      // Skip already processed packages
      if (List->IsNow(Pkg) == false)
	 continue;
	 
      new pkgAcqArchive(Owner,Sources,Recs,Cache[Pkg].InstVerIter(Cache),
			FileNames[Pkg->ID]);
   }

   return true;
}
									/*}}}*/
// PM::FixMissing - Keep all missing packages				/*{{{*/
// ---------------------------------------------------------------------
/* This is called to correct the installation when packages could not
   be downloaded. */
bool pkgPackageManager::FixMissing()
{
   pkgProblemResolver Resolve(Cache);

   bool Bad = false;
   for (PkgIterator I = Cache.PkgBegin(); I.end() == false; I++)
   {
      // These don't need files
      if (Cache[I].Keep() == true)
	 continue;
      if (Cache[I].Delete() == true)
	 continue;
      
      // We have a filename
      if (FileNames[I->ID].empty() == false)
	 continue;
      
      // Skip Packages that need configure only.
      if (I.State() == pkgCache::PkgIterator::NeedsConfigure && 
	  Cache[I].Keep() == true)
	 continue;
      
      // Okay, this file is missing and we need it. Mark it for keep 
      Bad = true;
      Cache.MarkKeep(I);
   }
   
   if (Bad == false)
      return true;
   
   // Now downgrade everything that is broken
   return Resolve.ResolveByKeep() == true && Cache.BrokenCount() == 0;   
}
									/*}}}*/

// PM::CreateOrderList - Create the ordering class			/*{{{*/
// ---------------------------------------------------------------------
/* This populates the ordering list with all the packages that are
   going to change. */
bool pkgPackageManager::CreateOrderList()
{
   if (List != 0)
      return true;
   
   delete List;
   List = new pkgOrderList(Cache);
   
   bool NoImmConfigure = _config->FindB("APT::Immediate-Configure",false);
   
   // Generate the list of affected packages and sort it
   for (PkgIterator I = Cache.PkgBegin(); I.end() == false; I++)
   {
      // Mark the package and its dependends for immediate configuration
      if (((I->Flags & pkgCache::Flag::Essential) == pkgCache::Flag::Essential ||
	   (I->Flags & pkgCache::Flag::Important) == pkgCache::Flag::Important) &&
	  NoImmConfigure == false)
      {
	 List->Flag(I,pkgOrderList::Immediate);
	 
	 // Look for other packages to make immediate configurea
	 if (Cache[I].InstallVer != 0)
	    for (DepIterator D = Cache[I].InstVerIter(Cache).DependsList(); 
		 D.end() == false; D++)
	       if (D->Type == pkgCache::Dep::Depends || D->Type == pkgCache::Dep::PreDepends)
		  List->Flag(D.TargetPkg(),pkgOrderList::Immediate);
	 
	 // And again with the current version.
	 if (I->CurrentVer != 0)
	    for (DepIterator D = I.CurrentVer().DependsList(); 
		 D.end() == false; D++)
	       if (D->Type == pkgCache::Dep::Depends || D->Type == pkgCache::Dep::PreDepends)
		  List->Flag(D.TargetPkg(),pkgOrderList::Immediate);
      }
      
      // Not interesting
      if ((Cache[I].Keep() == true || 
	  Cache[I].InstVerIter(Cache) == I.CurrentVer()) && 
	  I.State() == pkgCache::PkgIterator::NeedsNothing)
	 continue;
      
      // Append it to the list
      List->push_back(I);      
   }
   
   return true;
}
									/*}}}*/
// PM::DepAlwaysTrue - Returns true if this dep is irrelevent		/*{{{*/
// ---------------------------------------------------------------------
/* The restriction on provides is to eliminate the case when provides
   are transitioning between valid states [ie exim to smail] */
bool pkgPackageManager::DepAlwaysTrue(DepIterator D)
{
   if (D.TargetPkg()->ProvidesList != 0)
      return false;
   
   if ((Cache[D] & pkgDepCache::DepInstall) != 0 &&
       (Cache[D] & pkgDepCache::DepNow) != 0)
      return true;
   return false;
}
									/*}}}*/
// PM::CheckRConflicts - Look for reverse conflicts			/*{{{*/
// ---------------------------------------------------------------------
/* This looks over the reverses for a conflicts line that needs early
   removal. */
bool pkgPackageManager::CheckRConflicts(PkgIterator Pkg,DepIterator D,
					const char *Ver)
{
   for (;D.end() == false; D++)
   {
      if (D->Type != pkgCache::Dep::Conflicts)
	 continue;
      
      if (D.ParentPkg() == Pkg)
	 continue;
      
      if (pkgCheckDep(D.TargetVer(),Ver,D->CompareOp) == false)
	 continue;

      if (List->IsNow(Pkg) == false)
	 continue;
      
      if (EarlyRemove(D.ParentPkg()) == false)
	 return false;
   }  
   return true;
}
									/*}}}*/
// PM::ConfigureAll - Run the all out configuration			/*{{{*/
// ---------------------------------------------------------------------
/* This configures every package. It is assumed they are all unpacked and
   that the final configuration is valid. */
bool pkgPackageManager::ConfigureAll()
{
   pkgOrderList OList(Cache);
   
   // Populate the order list
   for (pkgOrderList::iterator I = List->begin(); I != List->end(); I++)
      if (List->IsFlag(pkgCache::PkgIterator(Cache,*I),
		       pkgOrderList::UnPacked) == true)
	 OList.push_back(*I);
   
   if (OList.OrderConfigure() == false)
      return false;
   
   // Perform the configuring
   for (pkgOrderList::iterator I = OList.begin(); I != OList.end(); I++)
   {
      PkgIterator Pkg(Cache,*I);
      
      if (Configure(Pkg) == false)
	 return false;
      
      List->Flag(Pkg,pkgOrderList::Configured,pkgOrderList::States);
   }
   
   return true;
}
									/*}}}*/
// PM::SmartConfigure - Perform immediate configuration of the pkg	/*{{{*/
// ---------------------------------------------------------------------
/* This routine scheduals the configuration of the given package and all
   of it's dependents. */
bool pkgPackageManager::SmartConfigure(PkgIterator Pkg)
{
   pkgOrderList OList(Cache);

   if (DepAdd(OList,Pkg) == false)
      return false;
   
   if (OList.OrderConfigure() == false)
      return false;

   // Perform the configuring
   for (pkgOrderList::iterator I = OList.begin(); I != OList.end(); I++)
   {
      PkgIterator Pkg(Cache,*I);
      
      if (Configure(Pkg) == false)
	 return false;
      
      List->Flag(Pkg,pkgOrderList::Configured,pkgOrderList::States);
   }

   // Sanity Check
   if (List->IsFlag(Pkg,pkgOrderList::Configured) == false)
      return _error->Error("Internal error, could not immediate configure %s",Pkg.Name());
   
   return true;
}
									/*}}}*/
// PM::DepAdd - Add all dependents to the oder list			/*{{{*/
// ---------------------------------------------------------------------
/* This recursively adds all dependents to the order list */
bool pkgPackageManager::DepAdd(pkgOrderList &OList,PkgIterator Pkg,int Depth)
{
   if (OList.IsFlag(Pkg,pkgOrderList::Added) == true)
      return true;
   if (List->IsFlag(Pkg,pkgOrderList::Configured) == true)
      return true;
   if (List->IsFlag(Pkg,pkgOrderList::UnPacked) == false)
      return false;
   
   
   // Put the package on the list
   OList.push_back(Pkg);
   OList.Flag(Pkg,pkgOrderList::Added);
   Depth++;

   // Check the dependencies to see if they are all satisfied.
   bool Bad = false;
   for (DepIterator D = Cache[Pkg].InstVerIter(Cache).DependsList(); D.end() == false;)
   {
      if (D->Type != pkgCache::Dep::Depends && D->Type != pkgCache::Dep::PreDepends)
      {
	 D++;
	 continue;
      }
      
      // Grok or groups
      Bad = true;
      for (bool LastOR = true; D.end() == false && LastOR == true; D++)
      {
	 LastOR = (D->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or;
	 
	 if (Bad == false)
	    continue;

	 Version **VList = D.AllTargets();
	 for (Version **I = VList; *I != 0 && Bad == true; I++)
	 {
	    VerIterator Ver(Cache,*I);
	    PkgIterator Pkg = Ver.ParentPkg();

	    // See if the current version is ok
	    if (Pkg.CurrentVer() == Ver && List->IsNow(Pkg) == true && 
		Pkg.State() == PkgIterator::NeedsNothing)
	    {
	       Bad = false;
	       continue;
	    }
	    
	    // Not the install version 
	    if (Cache[Pkg].InstallVer != *I || 
		(Cache[Pkg].Keep() == true && Pkg.State() == PkgIterator::NeedsNothing))
	       continue;
	    if (List->IsFlag(Pkg,pkgOrderList::UnPacked) == true)
	       Bad = !DepAdd(OList,Pkg,Depth);
	    if (List->IsFlag(Pkg,pkgOrderList::Configured) == true)
	       Bad = false;
	 }
	 delete [] VList;
      }
      
      if (Bad == true)
      {
	 OList.Flag(Pkg,0,pkgOrderList::Added);
	 OList.pop_back();
	 Depth--;
	 return false;
      }
   }
   
   Depth--;
   return true;
}
									/*}}}*/
// PM::EarlyRemove - Perform removal of packages before their time	/*{{{*/
// ---------------------------------------------------------------------
/* This is called to deal with conflicts arising from unpacking */
bool pkgPackageManager::EarlyRemove(PkgIterator Pkg)
{
   if (List->IsNow(Pkg) == false)
      return true;
	 
   // Already removed it
   if (List->IsFlag(Pkg,pkgOrderList::Removed) == true)
      return true;
   
   // Woops, it will not be re-installed!
   if (List->IsFlag(Pkg,pkgOrderList::InList) == false)
      return false;
   
   bool Res = SmartRemove(Pkg);
   if (Cache[Pkg].Delete() == false)
      List->Flag(Pkg,pkgOrderList::Removed,pkgOrderList::States);
   
   return Res;
}
									/*}}}*/
// PM::SmartRemove - Removal Helper					/*{{{*/
// ---------------------------------------------------------------------
/* */
bool pkgPackageManager::SmartRemove(PkgIterator Pkg)
{
   if (List->IsNow(Pkg) == false)
      return true;

   List->Flag(Pkg,pkgOrderList::Configured,pkgOrderList::States);
   return Remove(Pkg);
}
									/*}}}*/
// PM::SmartUnPack - Install helper					/*{{{*/
// ---------------------------------------------------------------------
/* This performs the task of handling pre-depends. */
bool pkgPackageManager::SmartUnPack(PkgIterator Pkg)
{
   // Check if it is already unpacked
   if (Pkg.State() == pkgCache::PkgIterator::NeedsConfigure &&
       Cache[Pkg].Keep() == true)
   {
      List->Flag(Pkg,pkgOrderList::UnPacked,pkgOrderList::States);
      if (List->IsFlag(Pkg,pkgOrderList::Immediate) == true)
	 if (SmartConfigure(Pkg) == false)
	    return _error->Error("Internal Error, Could not perform immediate configuraton");
      return true;
   }

   /* See if this packages install version has any predependencies
      that are not met by 'now' packages. */
   for (DepIterator D = Cache[Pkg].InstVerIter(Cache).DependsList(); 
	D.end() == false; D++)
   {
      if (D->Type == pkgCache::Dep::PreDepends)
      {
	 // Look for possible ok targets.
	 Version **VList = D.AllTargets();
	 bool Bad = true;
	 for (Version **I = VList; *I != 0 && Bad == true; I++)
	 {
	    VerIterator Ver(Cache,*I);
	    PkgIterator Pkg = Ver.ParentPkg();
	    
	    // See if the current version is ok
	    if (Pkg.CurrentVer() == Ver && List->IsNow(Pkg) == true && 
		Pkg.State() == PkgIterator::NeedsNothing)
	    {
	       Bad = false;
	       continue;
	    }
	 }
	 
	 // Look for something that could be configured.
	 for (Version **I = VList; *I != 0 && Bad == true; I++)
	 {
	    VerIterator Ver(Cache,*I);
	    PkgIterator Pkg = Ver.ParentPkg();
	    
	    // Not the install version 
	    if (Cache[Pkg].InstallVer != *I || 
		(Cache[Pkg].Keep() == true && Pkg.State() == PkgIterator::NeedsNothing))
	       continue;

	    Bad = !SmartConfigure(Pkg);
	 }
	 
	 delete [] VList;
	 
	 if (Bad == true)
	    return _error->Error("Internal Error, Couldn't configure a pre-depend");

	 continue;
      }
      
      if (D->Type == pkgCache::Dep::Conflicts)
      {
	 /* Look for conflicts. Two packages that are both in the install
	    state cannot conflict so we don't check.. */
	 Version **VList = D.AllTargets();
	 for (Version **I = VList; *I != 0; I++)
	 {
	    VerIterator Ver(Cache,*I);
	    PkgIterator Pkg = Ver.ParentPkg();
	    
	    // See if the current version is conflicting
	    if (Pkg.CurrentVer() == Ver && List->IsNow(Pkg) == true)
	    {
	       if (EarlyRemove(Pkg) == false)
		  return _error->Error("Internal Error, Could not early remove %s",Pkg.Name());
	    }
	 }
	 delete [] VList;
      }
   }

   // Check for reverse conflicts.
   CheckRConflicts(Pkg,Pkg.RevDependsList(),
		   Cache[Pkg].InstVerIter(Cache).VerStr());
   for (PrvIterator P = Cache[Pkg].InstVerIter(Cache).ProvidesList(); 
	P.end() == false; P++)
      CheckRConflicts(Pkg,P.ParentPkg().RevDependsList(),P.ProvideVersion());
   
   if (Install(Pkg,FileNames[Pkg->ID]) == false)
      return false;
   
   List->Flag(Pkg,pkgOrderList::UnPacked,pkgOrderList::States);
   
   // Perform immedate configuration of the package.
   if (List->IsFlag(Pkg,pkgOrderList::Immediate) == true)
      if (SmartConfigure(Pkg) == false)
	 return _error->Error("Internal Error, Could not perform immediate configuraton");
   
   return true;
}
									/*}}}*/
// PM::OrderInstall - Installation ordering routine			/*{{{*/
// ---------------------------------------------------------------------
/* */
pkgPackageManager::OrderResult pkgPackageManager::OrderInstall()
{
   if (CreateOrderList() == false)
      return Failed;

   Reset();
   
   if (Debug == true)
      clog << "Begining to order" << endl;

   if (List->OrderUnpack(FileNames) == false)
   {
      _error->Error("Internal ordering error");
      return Failed;
   }
   
   if (Debug == true)
      clog << "Done ordering" << endl;

   bool DoneSomething = false;
   for (pkgOrderList::iterator I = List->begin(); I != List->end(); I++)
   {
      PkgIterator Pkg(Cache,*I);

      if (List->IsNow(Pkg) == false)
      {
	 if (Debug == true)
	    clog << "Skipping already done " << Pkg.Name() << endl;
	 continue;
      }
      
      if (Cache[Pkg].Delete() == false && FileNames[Pkg->ID].empty() == true)
      {
	 if (Debug == true)
	    clog << "Sequence completed at" << Pkg.Name() << endl;
	 if (DoneSomething == false)
	 {
	    _error->Error("Internal Error, ordering was unable to handle the media swap");
	    return Failed;
	 }	 
	 return Incomplete;
      }
      
      // Sanity check
      if (Cache[Pkg].Keep() == true && Pkg.State() == pkgCache::PkgIterator::NeedsNothing)
      {
	 _error->Error("Internal Error, trying to manipulate a kept package");
	 return Failed;
      }
      
      // Perform a delete or an install
      if (Cache[Pkg].Delete() == true)
      {
	 if (SmartRemove(Pkg) == false)
	    return Failed;
      }
      else
	 if (SmartUnPack(Pkg) == false)
	    return Failed;
      DoneSomething = true;
   }
   
   // Final run through the configure phase
   if (ConfigureAll() == false)
      return Failed;

   // Sanity check
   for (pkgOrderList::iterator I = List->begin(); I != List->end(); I++)
   {
      if (List->IsFlag(*I,pkgOrderList::Configured) == false)
      {
	 _error->Error("Internal error, packages left unconfigured. %s",
		       PkgIterator(Cache,*I).Name());
	 return Failed;
      }
   }   
	 
   return Completed;
}
									/*}}}*/
// PM::DoInstall - Does the installation				/*{{{*/
// ---------------------------------------------------------------------
/* This uses the filenames in FileNames and the information in the
   DepCache to perform the installation of packages.*/
pkgPackageManager::OrderResult pkgPackageManager::DoInstall()
{
   OrderResult Res = OrderInstall();
   if (Res != Failed)
      if (Go() == false)
	 return Failed;
   return Res;
}
									/*}}}*/
Commit	Line	Data
6c139d6e AL	1	// -- mode: cpp; mode: fold --
6c139d6e AL	2	// Description /{{{/
281daf46	3	// $Id: packagemanager.cc,v 1.15 1999/07/03 03:10:35 jgg Exp $
6c139d6e AL	4	/* ######################################################################
	5
	6	Package Manager - Abstacts the package manager
	7
	8	More work is needed in the area of transitioning provides, ie exim
	9	replacing smail. This can cause interesing side effects.
	10
	11	Other cases involving conflicts+replaces should be tested.
	12
	13	##################################################################### */
	14	/}}}/
	15	// Include Files /{{{/
	16	#ifdef __GNUG__
094a497d	17	#pragma implementation "apt-pkg/packagemanager.h"
6c139d6e	18	#endif
094a497d AL	19	#include <apt-pkg/packagemanager.h>
	20	#include <apt-pkg/orderlist.h>
	21	#include <apt-pkg/depcache.h>
	22	#include <apt-pkg/error.h>
	23	#include <apt-pkg/version.h>
03e39e59	24	#include <apt-pkg/acquire-item.h>
30e1eab5 AL	25	#include <apt-pkg/algorithms.h>
30e1eab5 AL	26	#include <apt-pkg/configuration.h>
6c139d6e AL	27	/}}}/
	28
	29	// PM::PackageManager - Constructor /{{{/
	30	// ---------------------------------------------------------------------
	31	/* */
	32	pkgPackageManager::pkgPackageManager(pkgDepCache &Cache) : Cache(Cache)
	33	{
	34	FileNames = new string[Cache.Head().PackageCount];
	35	List = 0;
30e1eab5	36	Debug = _config->FindB("Debug::pkgPackageManager",false);
6c139d6e AL	37	}
	38	/}}}/
	39	// PM::PackageManager - Destructor /{{{/
	40	// ---------------------------------------------------------------------
	41	/* */
	42	pkgPackageManager::~pkgPackageManager()
	43	{
	44	delete List;
	45	delete [] FileNames;
	46	}
	47	/}}}/
03e39e59 AL	48	// PM::GetArchives - Queue the archives for download /{{{/
	49	// ---------------------------------------------------------------------
	50	/* */
	51	bool pkgPackageManager::GetArchives(pkgAcquire Owner,pkgSourceList Sources,
	52	pkgRecords *Recs)
	53	{
7a1b1f8b AL	54	if (CreateOrderList() == false)
	55	return false;
	56
	57	if (List->OrderUnpack() == false)
	58	return _error->Error("Internal ordering error");
	59
	60	for (pkgOrderList::iterator I = List->begin(); I != List->end(); I++)
	61	{
	62	PkgIterator Pkg(Cache,*I);
281daf46 AL	63	FileNames[Pkg->ID] = string();
281daf46 AL	64
7a1b1f8b AL	65	// Skip packages to erase
7a1b1f8b AL	66	if (Cache[Pkg].Delete() == true)
03e39e59	67	continue;
d38b7b3d AL	68
d38b7b3d AL	69	// Skip Packages that need configure only.
9dbb421f AL	70	if (Pkg.State() == pkgCache::PkgIterator::NeedsConfigure &&
9dbb421f AL	71	Cache[Pkg].Keep() == true)
d38b7b3d	72	continue;
281daf46 AL	73
	74	// Skip already processed packages
	75	if (List->IsNow(Pkg) == false)
	76	continue;
	77
7a1b1f8b AL	78	new pkgAcqArchive(Owner,Sources,Recs,Cache[Pkg].InstVerIter(Cache),
7a1b1f8b AL	79	FileNames[Pkg->ID]);
03e39e59	80	}
7a1b1f8b	81
03e39e59 AL	82	return true;
	83	}
	84	/}}}/
6c139d6e AL	85	// PM::FixMissing - Keep all missing packages /{{{/
	86	// ---------------------------------------------------------------------
	87	/* This is called to correct the installation when packages could not
	88	be downloaded. */
	89	bool pkgPackageManager::FixMissing()
	90	{
30e1eab5	91	pkgProblemResolver Resolve(Cache);
9dbb421f AL	92
9dbb421f AL	93	bool Bad = false;
6c139d6e AL	94	for (PkgIterator I = Cache.PkgBegin(); I.end() == false; I++)
6c139d6e AL	95	{
9dbb421f AL	96	// These don't need files
9dbb421f AL	97	if (Cache[I].Keep() == true)
6c139d6e	98	continue;
9dbb421f	99	if (Cache[I].Delete() == true)
6c139d6e	100	continue;
9dbb421f AL	101
	102	// We have a filename
	103	if (FileNames[I->ID].empty() == false)
	104	continue;
	105
	106	// Skip Packages that need configure only.
	107	if (I.State() == pkgCache::PkgIterator::NeedsConfigure &&
	108	Cache[I].Keep() == true)
	109	continue;
	110
	111	// Okay, this file is missing and we need it. Mark it for keep
	112	Bad = true;
6c139d6e AL	113	Cache.MarkKeep(I);
	114	}
	115
9dbb421f AL	116	if (Bad == false)
	117	return true;
	118
6c139d6e	119	// Now downgrade everything that is broken
30e1eab5	120	return Resolve.ResolveByKeep() == true && Cache.BrokenCount() == 0;
6c139d6e AL	121	}
	122	/}}}/
	123
7a1b1f8b AL	124	// PM::CreateOrderList - Create the ordering class /{{{/
	125	// ---------------------------------------------------------------------
	126	/* This populates the ordering list with all the packages that are
	127	going to change. */
	128	bool pkgPackageManager::CreateOrderList()
	129	{
281daf46 AL	130	if (List != 0)
	131	return true;
	132
7a1b1f8b AL	133	delete List;
	134	List = new pkgOrderList(Cache);
	135
b780bc1b	136	bool NoImmConfigure = _config->FindB("APT::Immediate-Configure",false);
079cc404	137
7a1b1f8b AL	138	// Generate the list of affected packages and sort it
	139	for (PkgIterator I = Cache.PkgBegin(); I.end() == false; I++)
	140	{
138d4b3d AL	141	// Mark the package and its dependends for immediate configuration
	142	if (((I->Flags & pkgCache::Flag::Essential) == pkgCache::Flag::Essential \|\|
	143	(I->Flags & pkgCache::Flag::Important) == pkgCache::Flag::Important) &&
079cc404	144	NoImmConfigure == false)
7a1b1f8b AL	145	{
7a1b1f8b AL	146	List->Flag(I,pkgOrderList::Immediate);
d38b7b3d AL	147
d38b7b3d AL	148	// Look for other packages to make immediate configurea
7a1b1f8b AL	149	if (Cache[I].InstallVer != 0)
	150	for (DepIterator D = Cache[I].InstVerIter(Cache).DependsList();
	151	D.end() == false; D++)
	152	if (D->Type == pkgCache::Dep::Depends \|\| D->Type == pkgCache::Dep::PreDepends)
	153	List->Flag(D.TargetPkg(),pkgOrderList::Immediate);
d38b7b3d AL	154
d38b7b3d AL	155	// And again with the current version.
7a1b1f8b AL	156	if (I->CurrentVer != 0)
	157	for (DepIterator D = I.CurrentVer().DependsList();
	158	D.end() == false; D++)
	159	if (D->Type == pkgCache::Dep::Depends \|\| D->Type == pkgCache::Dep::PreDepends)
	160	List->Flag(D.TargetPkg(),pkgOrderList::Immediate);
	161	}
	162
	163	// Not interesting
	164	if ((Cache[I].Keep() == true \|\|
	165	Cache[I].InstVerIter(Cache) == I.CurrentVer()) &&
	166	I.State() == pkgCache::PkgIterator::NeedsNothing)
	167	continue;
	168
	169	// Append it to the list
138d4b3d	170	List->push_back(I);
7a1b1f8b AL	171	}
	172
	173	return true;
	174	}
	175	/}}}/
6c139d6e AL	176	// PM::DepAlwaysTrue - Returns true if this dep is irrelevent /{{{/
	177	// ---------------------------------------------------------------------
	178	/* The restriction on provides is to eliminate the case when provides
	179	are transitioning between valid states [ie exim to smail] */
	180	bool pkgPackageManager::DepAlwaysTrue(DepIterator D)
	181	{
	182	if (D.TargetPkg()->ProvidesList != 0)
	183	return false;
	184
	185	if ((Cache[D] & pkgDepCache::DepInstall) != 0 &&
	186	(Cache[D] & pkgDepCache::DepNow) != 0)
	187	return true;
	188	return false;
	189	}
	190	/}}}/
	191	// PM::CheckRConflicts - Look for reverse conflicts /{{{/
	192	// ---------------------------------------------------------------------
	193	/* This looks over the reverses for a conflicts line that needs early
	194	removal. */
	195	bool pkgPackageManager::CheckRConflicts(PkgIterator Pkg,DepIterator D,
	196	const char *Ver)
	197	{
	198	for (;D.end() == false; D++)
	199	{
b50b2c97	200	if (D->Type != pkgCache::Dep::Conflicts)
6c139d6e AL	201	continue;
	202
	203	if (D.ParentPkg() == Pkg)
	204	continue;
	205
	206	if (pkgCheckDep(D.TargetVer(),Ver,D->CompareOp) == false)
	207	continue;
	208
	209	if (List->IsNow(Pkg) == false)
	210	continue;
	211
	212	if (EarlyRemove(D.ParentPkg()) == false)
	213	return false;
	214	}
	215	return true;
	216	}
	217	/}}}/
	218	// PM::ConfigureAll - Run the all out configuration /{{{/
	219	// ---------------------------------------------------------------------
	220	/* This configures every package. It is assumed they are all unpacked and
	221	that the final configuration is valid. */
	222	bool pkgPackageManager::ConfigureAll()
	223	{
	224	pkgOrderList OList(Cache);
	225
	226	// Populate the order list
	227	for (pkgOrderList::iterator I = List->begin(); I != List->end(); I++)
	228	if (List->IsFlag(pkgCache::PkgIterator(Cache,*I),
	229	pkgOrderList::UnPacked) == true)
	230	OList.push_back(*I);
	231
	232	if (OList.OrderConfigure() == false)
	233	return false;
	234
	235	// Perform the configuring
	236	for (pkgOrderList::iterator I = OList.begin(); I != OList.end(); I++)
	237	{
	238	PkgIterator Pkg(Cache,*I);
	239
	240	if (Configure(Pkg) == false)
	241	return false;
	242
	243	List->Flag(Pkg,pkgOrderList::Configured,pkgOrderList::States);
	244	}
	245
	246	return true;
	247	}
	248	/}}}/
	249	// PM::SmartConfigure - Perform immediate configuration of the pkg /{{{/
	250	// ---------------------------------------------------------------------
	251	/* This routine scheduals the configuration of the given package and all
	252	of it's dependents. */
	253	bool pkgPackageManager::SmartConfigure(PkgIterator Pkg)
	254	{
	255	pkgOrderList OList(Cache);
	256
	257	if (DepAdd(OList,Pkg) == false)
	258	return false;
	259
	260	if (OList.OrderConfigure() == false)
	261	return false;
	262
	263	// Perform the configuring
	264	for (pkgOrderList::iterator I = OList.begin(); I != OList.end(); I++)
265	{
266	PkgIterator Pkg(Cache,*I);
267
268	if (Configure(Pkg) == false)
269	return false;
270
271	List->Flag(Pkg,pkgOrderList::Configured,pkgOrderList::States);
272	}
273
274	// Sanity Check
275	if (List->IsFlag(Pkg,pkgOrderList::Configured) == false)
276	return _error->Error("Internal error, could not immediate configure %s",Pkg.Name());
277
278	return true;
279	}
280	/}}}/
281	// PM::DepAdd - Add all dependents to the oder list /{{{/
282	// ---------------------------------------------------------------------
283	/* This recursively adds all dependents to the order list */
284	bool pkgPackageManager::DepAdd(pkgOrderList &OList,PkgIterator Pkg,int Depth)
285	{
286	if (OList.IsFlag(Pkg,pkgOrderList::Added) == true)
287	return true;
288	if (List->IsFlag(Pkg,pkgOrderList::Configured) == true)
289	return true;
290	if (List->IsFlag(Pkg,pkgOrderList::UnPacked) == false)
291	return false;
292
293
294	// Put the package on the list
295	OList.push_back(Pkg);
296	OList.Flag(Pkg,pkgOrderList::Added);
297	Depth++;
298
299	// Check the dependencies to see if they are all satisfied.
300	bool Bad = false;
301	for (DepIterator D = Cache[Pkg].InstVerIter(Cache).DependsList(); D.end() == false;)
302	{
b50b2c97	303	if (D->Type != pkgCache::Dep::Depends && D->Type != pkgCache::Dep::PreDepends)
6c139d6e AL	304	{
	305	D++;
	306	continue;
	307	}
	308
	309	// Grok or groups
	310	Bad = true;
	311	for (bool LastOR = true; D.end() == false && LastOR == true; D++)
	312	{
b50b2c97	313	LastOR = (D->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or;
6c139d6e AL	314
	315	if (Bad == false)
	316	continue;
	317
	318	Version **VList = D.AllTargets();
	319	for (Version *I = VList; I != 0 && Bad == true; I++)
	320	{
	321	VerIterator Ver(Cache,*I);
	322	PkgIterator Pkg = Ver.ParentPkg();
	323
	324	// See if the current version is ok
	325	if (Pkg.CurrentVer() == Ver && List->IsNow(Pkg) == true &&
	326	Pkg.State() == PkgIterator::NeedsNothing)
	327	{
	328	Bad = false;
	329	continue;
	330	}
	331
	332	// Not the install version
	333	if (Cache[Pkg].InstallVer != *I \|\|
	334	(Cache[Pkg].Keep() == true && Pkg.State() == PkgIterator::NeedsNothing))
	335	continue;
	336	if (List->IsFlag(Pkg,pkgOrderList::UnPacked) == true)
	337	Bad = !DepAdd(OList,Pkg,Depth);
	338	if (List->IsFlag(Pkg,pkgOrderList::Configured) == true)
	339	Bad = false;
	340	}
	341	delete [] VList;
	342	}
	343
	344	if (Bad == true)
	345	{
	346	OList.Flag(Pkg,0,pkgOrderList::Added);
	347	OList.pop_back();
	348	Depth--;
	349	return false;
	350	}
	351	}
	352
	353	Depth--;
	354	return true;
	355	}
	356	/}}}/
	357	// PM::EarlyRemove - Perform removal of packages before their time /{{{/
	358	// ---------------------------------------------------------------------
	359	/* This is called to deal with conflicts arising from unpacking */
	360	bool pkgPackageManager::EarlyRemove(PkgIterator Pkg)
	361	{
	362	if (List->IsNow(Pkg) == false)
	363	return true;
	364
	365	// Already removed it
	366	if (List->IsFlag(Pkg,pkgOrderList::Removed) == true)
	367	return true;
	368
	369	// Woops, it will not be re-installed!
	370	if (List->IsFlag(Pkg,pkgOrderList::InList) == false)
	371	return false;
	372
	373	bool Res = SmartRemove(Pkg);
	374	if (Cache[Pkg].Delete() == false)
	375	List->Flag(Pkg,pkgOrderList::Removed,pkgOrderList::States);
	376
	377	return Res;
378	}
379	/}}}/
380	// PM::SmartRemove - Removal Helper /{{{/
381	// ---------------------------------------------------------------------
382	/* */
383	bool pkgPackageManager::SmartRemove(PkgIterator Pkg)
384	{
385	if (List->IsNow(Pkg) == false)
386	return true;
387
388	List->Flag(Pkg,pkgOrderList::Configured,pkgOrderList::States);
389	return Remove(Pkg);
390	}
391	/}}}/
392	// PM::SmartUnPack - Install helper /{{{/
393	// ---------------------------------------------------------------------
394	/* This performs the task of handling pre-depends. */
395	bool pkgPackageManager::SmartUnPack(PkgIterator Pkg)
396	{
397	// Check if it is already unpacked
398	if (Pkg.State() == pkgCache::PkgIterator::NeedsConfigure &&
399	Cache[Pkg].Keep() == true)
400	{
401	List->Flag(Pkg,pkgOrderList::UnPacked,pkgOrderList::States);
402	if (List->IsFlag(Pkg,pkgOrderList::Immediate) == true)
403	if (SmartConfigure(Pkg) == false)
404	return _error->Error("Internal Error, Could not perform immediate configuraton");
405	return true;
406	}
981d20eb	407
6c139d6e AL	408	/* See if this packages install version has any predependencies
	409	that are not met by 'now' packages. */
	410	for (DepIterator D = Cache[Pkg].InstVerIter(Cache).DependsList();
	411	D.end() == false; D++)
	412	{
b50b2c97	413	if (D->Type == pkgCache::Dep::PreDepends)
6c139d6e AL	414	{
	415	// Look for possible ok targets.
	416	Version **VList = D.AllTargets();
	417	bool Bad = true;
	418	for (Version *I = VList; I != 0 && Bad == true; I++)
	419	{
	420	VerIterator Ver(Cache,*I);
	421	PkgIterator Pkg = Ver.ParentPkg();
	422
	423	// See if the current version is ok
	424	if (Pkg.CurrentVer() == Ver && List->IsNow(Pkg) == true &&
	425	Pkg.State() == PkgIterator::NeedsNothing)
	426	{
	427	Bad = false;
	428	continue;
	429	}
	430	}
	431
	432	// Look for something that could be configured.
	433	for (Version *I = VList; I != 0 && Bad == true; I++)
	434	{
	435	VerIterator Ver(Cache,*I);
	436	PkgIterator Pkg = Ver.ParentPkg();
	437
	438	// Not the install version
	439	if (Cache[Pkg].InstallVer != *I \|\|
	440	(Cache[Pkg].Keep() == true && Pkg.State() == PkgIterator::NeedsNothing))
	441	continue;
	442
	443	Bad = !SmartConfigure(Pkg);
	444	}
	445
	446	delete [] VList;
	447
	448	if (Bad == true)
	449	return _error->Error("Internal Error, Couldn't configure a pre-depend");
	450
	451	continue;
	452	}
	453
b50b2c97	454	if (D->Type == pkgCache::Dep::Conflicts)
6c139d6e AL	455	{
	456	/* Look for conflicts. Two packages that are both in the install
	457	state cannot conflict so we don't check.. */
	458	Version **VList = D.AllTargets();
	459	for (Version *I = VList; I != 0; I++)
	460	{
	461	VerIterator Ver(Cache,*I);
	462	PkgIterator Pkg = Ver.ParentPkg();
	463
	464	// See if the current version is conflicting
	465	if (Pkg.CurrentVer() == Ver && List->IsNow(Pkg) == true)
	466	{
	467	if (EarlyRemove(Pkg) == false)
	468	return _error->Error("Internal Error, Could not early remove %s",Pkg.Name());
	469	}
	470	}
	471	delete [] VList;
	472	}
	473	}
	474
	475	// Check for reverse conflicts.
	476	CheckRConflicts(Pkg,Pkg.RevDependsList(),
	477	Cache[Pkg].InstVerIter(Cache).VerStr());
	478	for (PrvIterator P = Cache[Pkg].InstVerIter(Cache).ProvidesList();
	479	P.end() == false; P++)
	480	CheckRConflicts(Pkg,P.ParentPkg().RevDependsList(),P.ProvideVersion());
	481
	482	if (Install(Pkg,FileNames[Pkg->ID]) == false)
	483	return false;
	484
	485	List->Flag(Pkg,pkgOrderList::UnPacked,pkgOrderList::States);
	486
	487	// Perform immedate configuration of the package.
	488	if (List->IsFlag(Pkg,pkgOrderList::Immediate) == true)
	489	if (SmartConfigure(Pkg) == false)
	490	return _error->Error("Internal Error, Could not perform immediate configuraton");
	491
	492	return true;
	493	}
	494	/}}}/
	495	// PM::OrderInstall - Installation ordering routine /{{{/
	496	// ---------------------------------------------------------------------
	497	/* */
281daf46	498	pkgPackageManager::OrderResult pkgPackageManager::OrderInstall()
6c139d6e	499	{
7a1b1f8b	500	if (CreateOrderList() == false)
281daf46 AL	501	return Failed;
	502
	503	Reset();
6c139d6e	504
30e1eab5 AL	505	if (Debug == true)
30e1eab5 AL	506	clog << "Begining to order" << endl;
6c139d6e	507
281daf46 AL	508	if (List->OrderUnpack(FileNames) == false)
	509	{
	510	_error->Error("Internal ordering error");
	511	return Failed;
	512	}
	513
30e1eab5 AL	514	if (Debug == true)
	515	clog << "Done ordering" << endl;
	516
281daf46	517	bool DoneSomething = false;
6c139d6e AL	518	for (pkgOrderList::iterator I = List->begin(); I != List->end(); I++)
	519	{
	520	PkgIterator Pkg(Cache,*I);
281daf46 AL	521
	522	if (List->IsNow(Pkg) == false)
	523	{
	524	if (Debug == true)
	525	clog << "Skipping already done " << Pkg.Name() << endl;
	526	continue;
	527	}
	528
	529	if (Cache[Pkg].Delete() == false && FileNames[Pkg->ID].empty() == true)
	530	{
	531	if (Debug == true)
	532	clog << "Sequence completed at" << Pkg.Name() << endl;
	533	if (DoneSomething == false)
	534	{
	535	_error->Error("Internal Error, ordering was unable to handle the media swap");
	536	return Failed;
	537	}
	538	return Incomplete;
	539	}
6c139d6e AL	540
	541	// Sanity check
	542	if (Cache[Pkg].Keep() == true && Pkg.State() == pkgCache::PkgIterator::NeedsNothing)
281daf46 AL	543	{
	544	_error->Error("Internal Error, trying to manipulate a kept package");
	545	return Failed;
	546	}
6c139d6e AL	547
	548	// Perform a delete or an install
	549	if (Cache[Pkg].Delete() == true)
	550	{
	551	if (SmartRemove(Pkg) == false)
281daf46	552	return Failed;
6c139d6e AL	553	}
	554	else
	555	if (SmartUnPack(Pkg) == false)
281daf46 AL	556	return Failed;
281daf46 AL	557	DoneSomething = true;
6c139d6e AL	558	}
	559
	560	// Final run through the configure phase
	561	if (ConfigureAll() == false)
281daf46	562	return Failed;
6c139d6e AL	563
	564	// Sanity check
	565	for (pkgOrderList::iterator I = List->begin(); I != List->end(); I++)
281daf46	566	{
6c139d6e	567	if (List->IsFlag(*I,pkgOrderList::Configured) == false)
281daf46 AL	568	{
	569	_error->Error("Internal error, packages left unconfigured. %s",
	570	PkgIterator(Cache,*I).Name());
	571	return Failed;
	572	}
	573	}
	574
	575	return Completed;
6c139d6e AL	576	}
	577	/}}}/
	578	// PM::DoInstall - Does the installation /{{{/
	579	// ---------------------------------------------------------------------
	580	/* This uses the filenames in FileNames and the information in the
	581	DepCache to perform the installation of packages.*/
281daf46	582	pkgPackageManager::OrderResult pkgPackageManager::DoInstall()
6c139d6e	583	{
281daf46 AL	584	OrderResult Res = OrderInstall();
	585	if (Res != Failed)
	586	if (Go() == false)
	587	return Failed;
	588	return Res;
6c139d6e AL	589	}
6c139d6e AL	590	/}}}/