Merge remote-tracking branch 'upstream/debian/sid' into feature/install-progress-refactor

Conflicts:
	apt-pkg/deb/dpkgpm.cc
	apt-pkg/makefile

apt-pkg/algorithms.cc

@@ -336,217 +336,6 @@ bool pkgFixBroken(pkgDepCache &Cache)
    return Fix.Resolve(true);
 }
 									/*}}}*/
-// 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)
-{
-   std::string const solver = _config->Find("APT::Solver", "internal");
-   if (solver != "internal") {
-      OpTextProgress Prog(*_config);
-      return EDSP::ResolveExternal(solver.c_str(), Cache, false, true, false, &Prog);
-   }
-
-   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);
-
-   /* 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);
-
-   /* 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);
-   
-   /* 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);
-
-   pkgProblemResolver Fix(&Cache);
-
-   // 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);
-	 }
-      }
-   }
-   
-   return Fix.Resolve();
-}
-									/*}}}*/
-// 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)
-{
-   std::string const solver = _config->Find("APT::Solver", "internal");
-   if (solver != "internal") {
-      OpTextProgress Prog(*_config);
-      return EDSP::ResolveExternal(solver.c_str(), Cache, true, false, false, &Prog);
-   }
-
-   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);
-   }
-      
-   return Fix.ResolveByKeep();
-}
-									/*}}}*/
-// AllUpgradeNoDelete - Upgrade without removing packages		/*{{{*/
-// ---------------------------------------------------------------------
-/* Right now the system must be consistent before this can be called.
- * Upgrade as much as possible without deleting anything (useful for
- * stable systems)
- */
-bool pkgAllUpgradeNoDelete(pkgDepCache &Cache)
-{
-   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);
-      }
-   }
-
-   // 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);
-
-   // ... 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);
-
-   // resolve remaining issues via keep
-   return Fix.ResolveByKeep();
-}
-									/*}}}*/
-// 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 didnt 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;
-}
-									/*}}}*/
 // ProblemResolver::pkgProblemResolver - Constructor			/*{{{*/
 // ---------------------------------------------------------------------
 /* */
@@ -1548,102 +1337,3 @@ void pkgPrioSortList(pkgCache &Cache,pkgCache::Version **List)
    qsort(List,Count,sizeof(*List),PrioComp);
 }
 									/*}}}*/
-// ListUpdate - construct Fetcher and update the cache files		/*{{{*/
-// ---------------------------------------------------------------------
-/* This is a simple wrapper to update the cache. it will fetch stuff
- * from the network (or any other sources defined in sources.list)
- */
-bool ListUpdate(pkgAcquireStatus &Stat, 
-		pkgSourceList &List, 
-		int PulseInterval)
-{
-   pkgAcquire Fetcher;
-   if (Fetcher.Setup(&Stat, _config->FindDir("Dir::State::Lists")) == false)
-      return false;
-
-   // Populate it with the source selection
-   if (List.GetIndexes(&Fetcher) == false)
-	 return false;
-
-   return AcquireUpdate(Fetcher, PulseInterval, true);
-}
-									/*}}}*/
-// AcquireUpdate - take Fetcher and update the cache files		/*{{{*/
-// ---------------------------------------------------------------------
-/* This is a simple wrapper to update the cache with a provided acquire
- * If you only need control over Status and the used SourcesList use
- * ListUpdate method instead.
- */
-bool AcquireUpdate(pkgAcquire &Fetcher, int const PulseInterval,
-		   bool const RunUpdateScripts, bool const ListCleanup)
-{
-   // Run scripts
-   if (RunUpdateScripts == true)
-      RunScripts("APT::Update::Pre-Invoke");
-
-   pkgAcquire::RunResult res;
-   if(PulseInterval > 0)
-      res = Fetcher.Run(PulseInterval);
-   else
-      res = Fetcher.Run();
-
-   if (res == pkgAcquire::Failed)
-      return false;
-
-   bool Failed = false;
-   bool TransientNetworkFailure = false;
-   for (pkgAcquire::ItemIterator I = Fetcher.ItemsBegin(); 
-	I != Fetcher.ItemsEnd(); ++I)
-   {
-      if ((*I)->Status == pkgAcquire::Item::StatDone)
-	 continue;
-
-      (*I)->Finished();
-
-      ::URI uri((*I)->DescURI());
-      uri.User.clear();
-      uri.Password.clear();
-      string descUri = string(uri);
-      _error->Warning(_("Failed to fetch %s  %s\n"), descUri.c_str(),
-	      (*I)->ErrorText.c_str());
-
-      if ((*I)->Status == pkgAcquire::Item::StatTransientNetworkError) 
-      {
-	 TransientNetworkFailure = true;
-	 continue;
-      }
-
-      Failed = true;
-   }
-   
-   // Clean out any old list files
-   // Keep "APT::Get::List-Cleanup" name for compatibility, but
-   // this is really a global option for the APT library now
-   if (!TransientNetworkFailure && !Failed && ListCleanup == true &&
-       (_config->FindB("APT::Get::List-Cleanup",true) == true &&
-	_config->FindB("APT::List-Cleanup",true) == true))
-   {
-      if (Fetcher.Clean(_config->FindDir("Dir::State::lists")) == false ||
-	  Fetcher.Clean(_config->FindDir("Dir::State::lists") + "partial/") == false)
-	 // something went wrong with the clean
-	 return false;
-   }
-   
-   if (TransientNetworkFailure == true)
-      _error->Warning(_("Some index files failed to download. They have been ignored, or old ones used instead."));
-   else if (Failed == true)
-      return _error->Error(_("Some index files failed to download. They have been ignored, or old ones used instead."));
-
-
-   // Run the success scripts if all was fine
-   if (RunUpdateScripts == true)
-   {
-      if(!TransientNetworkFailure && !Failed)
-	 RunScripts("APT::Update::Post-Invoke-Success");
-
-      // Run the other scripts
-      RunScripts("APT::Update::Post-Invoke");
-   }
-   return true;
-}
-									/*}}}*/

apt-pkg/algorithms.h

@@ -40,10 +40,15 @@
 
 #ifndef APT_8_CLEANER_HEADERS
 #include <apt-pkg/acquire.h>
+// include pkg{DistUpgrade,AllUpgrade,MiniizeUpgrade} here for compatiblity
 using std::ostream;
 #endif
 
-class pkgAcquireStatus;
+#ifndef APT_9_CLEANER_HEADERS
+#include <apt-pkg/upgrade.h>
+#include <apt-pkg/update.h>
+#endif
+
 
 class pkgSimulate : public pkgPackageManager				/*{{{*/
 {
@@ -85,6 +90,7 @@ private:
 									/*}}}*/
 class pkgProblemResolver						/*{{{*/
 {
+ private:
    /** \brief dpointer placeholder (for later in case we need it) */
    void *d;
 
@@ -140,20 +146,10 @@ class pkgProblemResolver						/*{{{*/
    ~pkgProblemResolver();
 };
 									/*}}}*/
-bool pkgDistUpgrade(pkgDepCache &Cache);
 bool pkgApplyStatus(pkgDepCache &Cache);
 bool pkgFixBroken(pkgDepCache &Cache);
 
-bool pkgAllUpgrade(pkgDepCache &Cache);
-
-bool pkgAllUpgradeNoDelete(pkgDepCache &Cache);
-
-bool pkgMinimizeUpgrade(pkgDepCache &Cache);
-
 void pkgPrioSortList(pkgCache &Cache,pkgCache::Version **List);
 
-bool ListUpdate(pkgAcquireStatus &progress, pkgSourceList &List, int PulseInterval=0);
-bool AcquireUpdate(pkgAcquire &Fetcher, int const PulseInterval = 0,
-		   bool const RunUpdateScripts = true, bool const ListCleanup = true);
 
 #endif

apt-pkg/makefile

@@ -44,7 +44,7 @@ SOURCE+= pkgcache.cc version.cc depcache.cc \
 	 pkgsystem.cc indexfile.cc pkgcachegen.cc acquire-item.cc \
 	 indexrecords.cc vendor.cc vendorlist.cc cdrom.cc indexcopy.cc \
 	 aptconfiguration.cc cachefilter.cc cacheset.cc edsp.cc \
-	 install-progress.cc
+	 install-progress.cc upgrade.cc update.cc
 HEADERS+= algorithms.h depcache.h pkgcachegen.h cacheiterators.h \
 	  orderlist.h sourcelist.h packagemanager.h tagfile.h \
 	  init.h pkgcache.h version.h progress.h pkgrecords.h \
@@ -52,7 +52,8 @@ HEADERS+= algorithms.h depcache.h pkgcachegen.h cacheiterators.h \
 	  clean.h srcrecords.h cachefile.h versionmatch.h policy.h \
 	  pkgsystem.h indexfile.h metaindex.h indexrecords.h vendor.h \
 	  vendorlist.h cdrom.h indexcopy.h aptconfiguration.h \
-	  cachefilter.h cacheset.h edsp.h install-progress.h
+	  cachefilter.h cacheset.h edsp.h install-progress.h \
+	  upgrade.h update.h
 
 # Source code for the debian specific components
 # In theory the deb headers do not need to be exported..

apt-pkg/update.cc

@@ -0,0 +1,126 @@
+
+// Include Files							/*{{{*/
+#include <config.h>
+
+#include <apt-pkg/algorithms.h>
+#include <apt-pkg/update.h>
+#include <apt-pkg/error.h>
+#include <apt-pkg/configuration.h>
+#include <apt-pkg/version.h>
+#include <apt-pkg/sptr.h>
+#include <apt-pkg/acquire-item.h>
+#include <apt-pkg/edsp.h>
+#include <apt-pkg/sourcelist.h>
+#include <apt-pkg/fileutl.h>
+#include <apt-pkg/progress.h>
+
+#include <sys/types.h>
+#include <cstdlib>
+#include <algorithm>
+#include <iostream>
+#include <stdio.h>
+
+#include <apti18n.h>
+									/*}}}*/
+
+using namespace std;
+
+// ListUpdate - construct Fetcher and update the cache files		/*{{{*/
+// ---------------------------------------------------------------------
+/* This is a simple wrapper to update the cache. it will fetch stuff
+ * from the network (or any other sources defined in sources.list)
+ */
+bool ListUpdate(pkgAcquireStatus &Stat, 
+		pkgSourceList &List, 
+		int PulseInterval)
+{
+   pkgAcquire Fetcher;
+   if (Fetcher.Setup(&Stat, _config->FindDir("Dir::State::Lists")) == false)
+      return false;
+
+   // Populate it with the source selection
+   if (List.GetIndexes(&Fetcher) == false)
+	 return false;
+
+   return AcquireUpdate(Fetcher, PulseInterval, true);
+}
+									/*}}}*/
+// AcquireUpdate - take Fetcher and update the cache files		/*{{{*/
+// ---------------------------------------------------------------------
+/* This is a simple wrapper to update the cache with a provided acquire
+ * If you only need control over Status and the used SourcesList use
+ * ListUpdate method instead.
+ */
+bool AcquireUpdate(pkgAcquire &Fetcher, int const PulseInterval,
+		   bool const RunUpdateScripts, bool const ListCleanup)
+{
+   // Run scripts
+   if (RunUpdateScripts == true)
+      RunScripts("APT::Update::Pre-Invoke");
+
+   pkgAcquire::RunResult res;
+   if(PulseInterval > 0)
+      res = Fetcher.Run(PulseInterval);
+   else
+      res = Fetcher.Run();
+
+   if (res == pkgAcquire::Failed)
+      return false;
+
+   bool Failed = false;
+   bool TransientNetworkFailure = false;
+   for (pkgAcquire::ItemIterator I = Fetcher.ItemsBegin(); 
+	I != Fetcher.ItemsEnd(); ++I)
+   {
+      if ((*I)->Status == pkgAcquire::Item::StatDone)
+	 continue;
+
+      (*I)->Finished();
+
+      ::URI uri((*I)->DescURI());
+      uri.User.clear();
+      uri.Password.clear();
+      string descUri = string(uri);
+      _error->Warning(_("Failed to fetch %s  %s\n"), descUri.c_str(),
+	      (*I)->ErrorText.c_str());
+
+      if ((*I)->Status == pkgAcquire::Item::StatTransientNetworkError) 
+      {
+	 TransientNetworkFailure = true;
+	 continue;
+      }
+
+      Failed = true;
+   }
+   
+   // Clean out any old list files
+   // Keep "APT::Get::List-Cleanup" name for compatibility, but
+   // this is really a global option for the APT library now
+   if (!TransientNetworkFailure && !Failed && ListCleanup == true &&
+       (_config->FindB("APT::Get::List-Cleanup",true) == true &&
+	_config->FindB("APT::List-Cleanup",true) == true))
+   {
+      if (Fetcher.Clean(_config->FindDir("Dir::State::lists")) == false ||
+	  Fetcher.Clean(_config->FindDir("Dir::State::lists") + "partial/") == false)
+	 // something went wrong with the clean
+	 return false;
+   }
+   
+   if (TransientNetworkFailure == true)
+      _error->Warning(_("Some index files failed to download. They have been ignored, or old ones used instead."));
+   else if (Failed == true)
+      return _error->Error(_("Some index files failed to download. They have been ignored, or old ones used instead."));
+
+
+   // Run the success scripts if all was fine
+   if (RunUpdateScripts == true)
+   {
+      if(!TransientNetworkFailure && !Failed)
+	 RunScripts("APT::Update::Post-Invoke-Success");
+
+      // Run the other scripts
+      RunScripts("APT::Update::Post-Invoke");
+   }
+   return true;
+}
+									/*}}}*/

apt-pkg/update.h

@@ -0,0 +1,21 @@
+// -*- mode: cpp; mode: fold -*-
+// Description								/*{{{*/
+/* ######################################################################
+
+   Update - ListUpdate releated code
+   
+   ##################################################################### */
+									/*}}}*/
+
+#ifndef PKGLIB_UPDATE_H
+#define PKGLIB_UPDATE_H
+
+class pkgAcquireStatus;
+
+
+bool ListUpdate(pkgAcquireStatus &progress, pkgSourceList &List, int PulseInterval=0);
+bool AcquireUpdate(pkgAcquire &Fetcher, int const PulseInterval = 0,
+		   bool const RunUpdateScripts = true, bool const ListCleanup = true);
+
+
+#endif

apt-pkg/upgrade.cc

@@ -0,0 +1,263 @@
+
+// Include Files							/*{{{*/
+#include <config.h>
+
+#include <apt-pkg/algorithms.h>
+#include <apt-pkg/upgrade.h>
+#include <apt-pkg/error.h>
+#include <apt-pkg/configuration.h>
+#include <apt-pkg/version.h>
+#include <apt-pkg/sptr.h>
+#include <apt-pkg/acquire-item.h>
+#include <apt-pkg/edsp.h>
+#include <apt-pkg/sourcelist.h>
+#include <apt-pkg/fileutl.h>
+#include <apt-pkg/progress.h>
+
+#include <sys/types.h>
+#include <cstdlib>
+#include <algorithm>
+#include <iostream>
+#include <stdio.h>
+
+#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)
+{
+   std::string const solver = _config->Find("APT::Solver", "internal");
+   if (solver != "internal") {
+      OpTextProgress Prog(*_config);
+      return EDSP::ResolveExternal(solver.c_str(), Cache, false, true, false, &Prog);
+   }
+
+   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);
+
+   /* 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);
+
+   /* 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);
+   
+   /* 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);
+
+   pkgProblemResolver Fix(&Cache);
+
+   // 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);
+	 }
+      }
+   }
+   
+   return Fix.Resolve();
+}
+									/*}}}*/
+// AllUpgradeNoNewPackages - Upgrade but no removals or new pkgs        /*{{{*/
+static bool pkgAllUpgradeNoNewPackages(pkgDepCache &Cache)
+{
+   std::string const solver = _config->Find("APT::Solver", "internal");
+   if (solver != "internal") {
+      OpTextProgress Prog(*_config);
+      return EDSP::ResolveExternal(solver.c_str(), Cache, true, false, false, &Prog);
+   }
+
+   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);
+   }
+      
+   return Fix.ResolveByKeep();
+}
+									/*}}}*/
+// 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)
+{
+   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);
+      }
+   }
+
+   // 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);
+
+   // ... 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);
+
+   // resolve remaining issues via keep
+   return Fix.ResolveByKeep();
+}
+									/*}}}*/
+// 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)
+{
+   return pkgAllUpgradeNoNewPackages(Cache);
+}
+									/*}}}*/
+// 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 didnt 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)
+{
+   if (mode == 0) 
+   {
+      return pkgDistUpgrade(Cache);
+   }
+   else if ((mode & ~FORBID_REMOVE_PACKAGES) == 0)
+   {
+      return pkgAllUpgradeWithNewPackages(Cache);
+   } 
+   else if ((mode & ~(FORBID_REMOVE_PACKAGES|FORBID_INSTALL_NEW_PACKAGES)) == 0)
+   {
+      return pkgAllUpgradeNoNewPackages(Cache);
+   }
+   else
+      _error->Error("pkgAllUpgrade called with unsupported mode %i", mode);
+
+   return false;
+}
+									/*}}}*/

apt-pkg/upgrade.h

@@ -0,0 +1,30 @@
+// -*- mode: cpp; mode: fold -*-
+// Description								/*{{{*/
+/* ######################################################################
+
+   Upgrade - Upgrade/DistUpgrade releated code
+   
+   ##################################################################### */
+									/*}}}*/
+
+#ifndef PKGLIB_UPGRADE_H
+#define PKGLIB_UPGRADE_H
+
+namespace APT {
+   namespace Upgrade {
+      // FIXME: make this "enum class UpgradeMode {" once we enable c++11
+      enum UpgradeMode {
+         FORBID_REMOVE_PACKAGES = 1,
+         FORBID_INSTALL_NEW_PACKAGES = 2,
+      };
+      bool Upgrade(pkgDepCache &Cache, int UpgradeMode);
+   }
+}
+
+// please use APT::Upgrade::Upgrade() instead
+bool pkgDistUpgrade(pkgDepCache &Cache);
+bool pkgAllUpgrade(pkgDepCache &Cache);
+bool pkgMinimizeUpgrade(pkgDepCache &Cache);
+
+
+#endif

apt-private/private-cachefile.cc

@@ -2,6 +2,7 @@
 #include<config.h>
 
 #include <apt-pkg/algorithms.h>
+#include <apt-pkg/upgrade.h>
 #include <apt-pkg/error.h>
 
 #include <cstdlib>

apt-private/private-update.cc

@@ -23,6 +23,7 @@
 #include <apt-pkg/pkgsystem.h>
 #include <apt-pkg/pkgrecords.h>
 #include <apt-pkg/indexfile.h>
+#include <apt-pkg/update.h>
 
 #include <sys/types.h>
 #include <sys/stat.h>

apt-private/private-upgrade.cc

@@ -1,28 +1,28 @@
 // Includes								/*{{{*/
 #include <apt-pkg/algorithms.h>
-
+#include <apt-pkg/upgrade.h>
+#include <iostream>
 #include "private-install.h"
 #include "private-cachefile.h"
 #include "private-upgrade.h"
 #include "private-output.h"
 									/*}}}*/
 
-// DoUpgradeNoNewPackages - Upgrade all packages			/*{{{*/
-// ---------------------------------------------------------------------
-/* Upgrade all packages without installing new packages or erasing old
-   packages */
-bool DoUpgradeNoNewPackages(CommandLine &CmdL)
+// this is actually performing the various upgrade operations 
+static bool UpgradeHelper(CommandLine &CmdL, int UpgradeFlags)
 {
    CacheFile Cache;
    if (Cache.OpenForInstall() == false || Cache.CheckDeps() == false)
       return false;
 
-   // Do the upgrade
-   if (pkgAllUpgrade(Cache) == false)
+   c0out << _("Calculating upgrade... ") << std::flush;
+   if (APT::Upgrade::Upgrade(Cache, UpgradeFlags) == false)
    {
+      c0out << _("Failed") << std::endl;
       ShowBroken(c1out,Cache,false);
-      return _error->Error(_("Internal error, AllUpgrade broke stuff"));
+      return _error->Error(_("Internal error, Upgrade broke stuff"));
    }
+   c0out << _("Done") << std::endl;
 
    // parse additional cmdline pkg manipulation switches
    if(!DoCacheManipulationFromCommandLine(CmdL, Cache))
@@ -30,25 +30,30 @@ bool DoUpgradeNoNewPackages(CommandLine &CmdL)
    
    return InstallPackages(Cache,true);
 }
+
+// DoDistUpgrade - Automatic smart upgrader				/*{{{*/
+// ---------------------------------------------------------------------
+/* Intelligent upgrader that will install and remove packages at will */
+bool DoDistUpgrade(CommandLine &CmdL)
+{
+   return UpgradeHelper(CmdL, 0);
+}
+									/*}}}*/
+// DoUpgradeNoNewPackages - Upgrade all packages			/*{{{*/
+// ---------------------------------------------------------------------
+/* Upgrade all packages without installing new packages or erasing old
+   packages */
+bool DoUpgradeNoNewPackages(CommandLine &CmdL)
+{
+   // Do the upgrade
+   return UpgradeHelper(CmdL, 
+                        APT::Upgrade::FORBID_REMOVE_PACKAGES|
+                        APT::Upgrade::FORBID_INSTALL_NEW_PACKAGES);
+}
 									/*}}}*/
 // DoSafeUpgrade - Upgrade all packages with install but not remove	/*{{{*/
 bool DoUpgradeWithAllowNewPackages(CommandLine &CmdL)
 {
-   CacheFile Cache;
-   if (Cache.OpenForInstall() == false || Cache.CheckDeps() == false)
-      return false;
-
-   // Do the upgrade
-   if (pkgAllUpgradeNoDelete(Cache) == false)
-   {
-      ShowBroken(c1out,Cache,false);
-      return _error->Error(_("Internal error, AllUpgrade broke stuff"));
-   }
-
-   // parse additional cmdline pkg manipulation switches
-   if(!DoCacheManipulationFromCommandLine(CmdL, Cache))
-      return false;
-   
-   return InstallPackages(Cache,true);
+   return UpgradeHelper(CmdL, APT::Upgrade::FORBID_REMOVE_PACKAGES);
 }
 									/*}}}*/

apt-private/private-upgrade.h

@@ -4,6 +4,7 @@
 #include <apt-pkg/cmndline.h>
 
 
+bool DoDistUpgrade(CommandLine &CmdL);
 bool DoUpgradeNoNewPackages(CommandLine &CmdL);
 bool DoUpgradeWithAllowNewPackages(CommandLine &CmdL);
 

buildlib/config.h.in

@@ -41,3 +41,4 @@
 #undef PACKAGE_MAIL
 
 #define APT_8_CLEANER_HEADERS
+#define APT_9_CLEANER_HEADERS

cmdline/apt-get.cc

@@ -49,6 +49,7 @@
 #include <apt-pkg/pkgsystem.h>
 #include <apt-pkg/pkgrecords.h>
 #include <apt-pkg/indexfile.h>
+#include <apt-pkg/upgrade.h>
 
 #include <apt-private/private-download.h>
 #include <apt-private/private-install.h>
@@ -343,32 +344,6 @@ bool DoMarkAuto(CommandLine &CmdL)
    return false;
 }
 									/*}}}*/
-// DoDistUpgrade - Automatic smart upgrader				/*{{{*/
-// ---------------------------------------------------------------------
-/* Intelligent upgrader that will install and remove packages at will */
-bool DoDistUpgrade(CommandLine &CmdL)
-{
-   CacheFile Cache;
-   if (Cache.OpenForInstall() == false || Cache.CheckDeps() == false)
-      return false;
-
-   c0out << _("Calculating upgrade... ") << flush;
-   if (pkgDistUpgrade(*Cache) == false)
-   {
-      c0out << _("Failed") << endl;
-      ShowBroken(c1out,Cache,false);
-      return false;
-   }
-   
-   // parse additional cmdline pkg manipulation switches
-   if(!DoCacheManipulationFromCommandLine(CmdL, Cache))
-      return false;
-
-   c0out << _("Done") << endl;
-   
-   return InstallPackages(Cache,true);
-}
-									/*}}}*/
 // DoDSelectUpgrade - Do an upgrade by following dselects selections	/*{{{*/
 // ---------------------------------------------------------------------
 /* Follows dselect's selections */

cmdline/apt-internal-solver.cc

@@ -19,6 +19,7 @@
 #include <apt-pkg/algorithms.h>
 #include <apt-pkg/fileutl.h>
 #include <apt-pkg/pkgsystem.h>
+#include <apt-pkg/upgrade.h>
 
 #include <unistd.h>
 #include <cstdio>

doc/apt-verbatim.ent

@@ -124,6 +124,12 @@
   </citerefentry>"
 >
 
+<!ENTITY squid-deb-proxy-client "<citerefentry>
+    <refentrytitle><command>squid-deb-proxy-client</command></refentrytitle>
+    <manvolnum>1</manvolnum>
+  </citerefentry>"
+>
+
 <!ENTITY debsign "<citerefentry>
     <refentrytitle><command>debsign</command></refentrytitle>
     <manvolnum>1</manvolnum>

doc/apt.conf.5.xml

@@ -396,6 +396,14 @@ DPkg::Pre-Install-Pkgs {"/usr/sbin/dpkg-preconfigure --apt";};
      <para><literal>Acquire::http::User-Agent</literal> can be used to set a different
      User-Agent for the http download method as some proxies allow access for clients
      only if the client uses a known identifier.</para>
+
+     <para><literal>Acquire::http::Proxy-Auto-Detect</literal> can be used to
+     specify a external command to discover the http proxy to use. Apt expects
+     the command to output the proxy on stdout in the style
+     <literal>http://proxy:port/</literal>. See the 
+     &squid-deb-proxy-client; package for a example implementation that
+     uses avahi.</para>
+
      </listitem>
      </varlistentry>
 

methods/http.cc

@@ -798,7 +798,6 @@ bool HttpMethod::Configuration(string Message)
    PipelineDepth = _config->FindI("Acquire::http::Pipeline-Depth",
 				  PipelineDepth);
    Debug = _config->FindB("Debug::Acquire::http",false);
-   AutoDetectProxyCmd = _config->Find("Acquire::http::ProxyAutoDetect");
 
    // Get the proxy to use
    AutoDetectProxy();
@@ -811,6 +810,11 @@ bool HttpMethod::Configuration(string Message)
 /* */
 bool HttpMethod::AutoDetectProxy()
 {
+   // option is "Acquire::http::Proxy-Auto-Detect" but we allow the old
+   // name without the dash ("-")
+   AutoDetectProxyCmd = _config->Find("Acquire::http::Proxy-Auto-Detect",
+                                      _config->Find("Acquire::http::ProxyAutoDetect"));
+
    if (AutoDetectProxyCmd.empty())
       return true;
 

test/integration/framework

@@ -116,7 +116,7 @@ aptitude() {
 }
 gdb() {
 	echo "gdb: run »$*«"
-	APT_CONFIG=aptconfig.conf LD_LIBRARY_PATH=${BUILDDIRECTORY} $(which gdb) ${BUILDDIRECTORY}/$1
+	APT_CONFIG=aptconfig.conf LD_LIBRARY_PATH=${BUILDDIRECTORY} $(which gdb) ${BUILDDIRECTORY}/$1 --args $*
 }
 http() {
 	LD_LIBRARY_PATH=${BUILDDIRECTORY} ${BUILDDIRECTORY}/methods/http

test/integration/run-tests

@@ -2,6 +2,7 @@
 set -e
 
 FAIL=0
+FAILED_TESTS=""
 DIR=$(readlink -f $(dirname $0))
 if [ "$1" = "-q" ]; then
 	export MSGLEVEL=2
@@ -29,6 +30,7 @@ for testcase in $(run-parts --list $DIR | grep '/test-'); do
 	fi
 	if ! ${testcase}; then
                  FAIL=$((FAIL+1))
+                 FAILED_TESTS="$FAILED_TESTS $(basename $testcase)"
                  echo "$(basename $testcase) ... FAIL"
         fi
 	if [ "$MSGLEVEL" -le 2 ]; then
@@ -37,5 +39,8 @@ for testcase in $(run-parts --list $DIR | grep '/test-'); do
 done
 
 echo "failures: $FAIL"
+if [ -n "$FAILED_TESTS" ]; then 
+    echo "Failed tests: $FAILED_TESTS";
+fi
 # ensure we don't overflow
 exit $((FAIL <= 255 ? FAIL : 255))

test/integration/test-apt-progress-fd-error

@@ -18,5 +18,5 @@ setupaptarchive
 exec 3> apt-progress.log
 testfailure aptget install foo1 foo2 -y -o APT::Status-Fd=3
 msgtest "Ensure correct error message"
-grep -q "aptarchive/pool/foo2_0.8.15_amd64.deb :40:trying to overwrite '/usr/bin/file-conflict', which is also in package foo1 0.8.15" apt-progress.log && msgpass || msgfail
+grep -q "aptarchive/pool/foo2_0.8.15_amd64.deb :40:trying to overwrite '/usr/bin/file-conflict', which is also in package foo1 0.8.15" apt-progress.log && msgpass || (cat apt-progress.log && msgfail)