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

// -*- mode: cpp; mode: fold -*-
// Description								/*{{{*/
// $Id: packagemanager.cc,v 1.12 1999/01/31 06:24:46 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);

      // Skip packages to erase
      if (Cache[Pkg].Delete() == true)
	 continue;

      // Skip Packages that need configure only.
      if (Pkg.State() == pkgCache::PkgIterator::NeedsConfigure)
	 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);
   
   for (PkgIterator I = Cache.PkgBegin(); I.end() == false; I++)
   {
     if (Cache[I].Keep() == true)
	 continue;
      if (FileNames[I->ID].empty() == false || Cache[I].Delete() == true)
	 continue;
      Cache.MarkKeep(I);
   }
   
   // 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()
{
   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 for immediate configuration
      if ((I->Flags & pkgCache::Flag::Essential) == pkgCache::Flag::Essential &&
	  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);
      
      if ((I->Flags & pkgCache::Flag::ImmediateConf) == pkgCache::Flag::ImmediateConf)
	 List->Flag(I,pkgOrderList::Immediate);
   }
   
   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			/*{{{*/
// ---------------------------------------------------------------------
/* */
bool pkgPackageManager::OrderInstall()
{
   if (CreateOrderList() == false)
      return false;
   
   if (Debug == true)
      clog << "Begining to order" << endl;
   
   if (List->OrderUnpack() == false)
      return _error->Error("Internal ordering error");

   if (Debug == true)
      clog << "Done ordering" << endl;

   for (pkgOrderList::iterator I = List->begin(); I != List->end(); I++)
   {
      PkgIterator Pkg(Cache,*I);
      
      // Sanity check
      if (Cache[Pkg].Keep() == true && Pkg.State() == pkgCache::PkgIterator::NeedsNothing)
	 return _error->Error("Internal Error, trying to manipulate a kept package");
      
      // Perform a delete or an install
      if (Cache[Pkg].Delete() == true)
      {
	 if (SmartRemove(Pkg) == false)
	    return false;	 
      }
      else
	 if (SmartUnPack(Pkg) == false)
	    return false;
   }
   
   // Final run through the configure phase
   if (ConfigureAll() == false)
      return false;

   // Sanity check
   for (pkgOrderList::iterator I = List->begin(); I != List->end(); I++)
      if (List->IsFlag(*I,pkgOrderList::Configured) == false)
	 return _error->Error("Internal error, packages left unconfigured. %s",
			      PkgIterator(Cache,*I).Name());

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