Adding upstream version 1.8.2.3.upstream/1.8.2.3upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 195 insertions, 0 deletions

diff --git a/cmdline/apt-internal-planner.cc b/cmdline/apt-internal-planner.cc
new file mode 100644
index 0000000..be9de4e
--- /dev/null
+++ b/cmdline/apt-internal-planner.cc
@@ -0,0 +1,195 @@
+// -*- mode: cpp; mode: fold -*-
+// Description								/*{{{*/
+/* #####################################################################
+
+   cover around the internal solver to be able to run it like an external
+
+   ##################################################################### */
+									/*}}}*/
+// Include Files							/*{{{*/
+#include <config.h>
+
+#include <apt-pkg/cachefile.h>
+#include <apt-pkg/cacheset.h>
+#include <apt-pkg/cmndline.h>
+#include <apt-pkg/configuration.h>
+#include <apt-pkg/depcache.h>
+#include <apt-pkg/edsp.h>
+#include <apt-pkg/error.h>
+#include <apt-pkg/fileutl.h>
+#include <apt-pkg/init.h>
+#include <apt-pkg/packagemanager.h>
+#include <apt-pkg/pkgcache.h>
+#include <apt-pkg/pkgsystem.h>
+#include <apt-pkg/prettyprinters.h>
+#include <apt-pkg/strutl.h>
+
+#include <apt-private/private-cmndline.h>
+#include <apt-private/private-main.h>
+#include <apt-private/private-output.h>
+
+#include <cstdio>
+#include <iostream>
+#include <list>
+#include <sstream>
+#include <string>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <apti18n.h>
+									/*}}}*/
+
+static bool ShowHelp(CommandLine &)					/*{{{*/
+{
+	std::cout <<
+		_("Usage: apt-internal-planner\n"
+		"\n"
+		"apt-internal-planner is an interface to use the current internal\n"
+		"installation planner for the APT family like an external one,\n"
+		"for debugging or the like.\n");
+	return true;
+}
+									/*}}}*/
+APT_NORETURN static void DIE(std::string const &message) {		/*{{{*/
+	std::cerr << "ERROR: " << message << std::endl;
+	_error->DumpErrors(std::cerr);
+	exit(EXIT_FAILURE);
+}
+									/*}}}*/
+static std::vector<aptDispatchWithHelp> GetCommands()			/*{{{*/
+{
+   return {};
+}
+									/*}}}*/
+class PMOutput: public pkgPackageManager				/*{{{*/
+{
+   FileFd &output;
+   bool const Debug;
+
+protected:
+   virtual bool Install(PkgIterator Pkg,std::string) APT_OVERRIDE
+   {
+      //std::cerr << "INSTALL: " << APT::PrettyPkg(&Cache, Pkg) << std::endl;
+      return EDSP::WriteSolutionStanza(output, "Unpack", Cache[Pkg].InstVerIter(Cache));
+   }
+   virtual bool Configure(PkgIterator Pkg) APT_OVERRIDE
+   {
+      //std::cerr << "CONFIGURE: " << APT::PrettyPkg(&Cache, Pkg) << " " << std::endl;
+      return EDSP::WriteSolutionStanza(output, "Configure", Cache[Pkg].InstVerIter(Cache));
+   }
+   virtual bool Remove(PkgIterator Pkg,bool) APT_OVERRIDE
+   {
+      //std::cerr << "REMOVE: " << APT::PrettyPkg(&Cache, Pkg) << " " << std::endl;
+      return EDSP::WriteSolutionStanza(output, "Remove", Pkg.CurrentVer());
+   }
+public:
+   PMOutput(pkgDepCache *Cache, FileFd &file) : pkgPackageManager(Cache), output(file),
+      Debug(_config->FindB("Debug::EDSP::WriteSolution", false))
+   {}
+
+   bool ApplyRequest(std::list<std::pair<std::string,EIPP::PKG_ACTION>> const &actions)
+   {
+      for (auto && a: actions)
+      {
+	 auto const Pkg = Cache.FindPkg(a.first);
+	 if (unlikely(Pkg.end() == true))
+	    continue;
+	 switch (a.second)
+	 {
+	    case EIPP::PKG_ACTION::NOOP:
+	       break;
+	    case EIPP::PKG_ACTION::INSTALL:
+	    case EIPP::PKG_ACTION::REINSTALL:
+	       FileNames[Pkg->ID] = "EIPP";
+	       break;
+	    case EIPP::PKG_ACTION::REMOVE:
+	       break;
+	 }
+      }
+      return true;
+   }
+};
+									/*}}}*/
+int main(int argc,const char *argv[])					/*{{{*/
+{
+	// we really don't need anything
+	DropPrivileges();
+
+	CommandLine CmdL;
+	ParseCommandLine(CmdL, APT_CMD::APT_INTERNAL_PLANNER, &_config, NULL, argc, argv, &ShowHelp, &GetCommands);
+
+	// Deal with stdout not being a tty
+	if (!isatty(STDOUT_FILENO) && _config->FindI("quiet", -1) == -1)
+		_config->Set("quiet","1");
+
+	if (_config->FindI("quiet", 0) < 1)
+		_config->Set("Debug::EIPP::WriteSolution", true);
+
+	_config->Set("APT::System", "Debian APT planner interface");
+	_config->Set("APT::Planner", "internal");
+	_config->Set("eipp::scenario", "/nonexistent/stdin");
+	FileFd output;
+	if (output.OpenDescriptor(STDOUT_FILENO, FileFd::WriteOnly | FileFd::BufferedWrite, true) == false)
+	   DIE("stdout couldn't be opened");
+	int const input = STDIN_FILENO;
+	SetNonBlock(input, false);
+
+	EDSP::WriteProgress(0, "Start up planner…", output);
+
+	if (pkgInitSystem(*_config,_system) == false)
+		DIE("System could not be initialized!");
+
+	EDSP::WriteProgress(1, "Read request…", output);
+
+	if (WaitFd(input, false, 5) == false)
+		DIE("WAIT timed out in the planner");
+
+	std::list<std::pair<std::string,EIPP::PKG_ACTION>> actions;
+	unsigned int flags;
+	if (EIPP::ReadRequest(input, actions, flags) == false)
+		DIE("Parsing the request failed!");
+	_config->Set("APT::Immediate-Configure", (flags & EIPP::Request::NO_IMMEDIATE_CONFIGURATION) == 0);
+	_config->Set("APT::Immediate-Configure-All", (flags & EIPP::Request::IMMEDIATE_CONFIGURATION_ALL) != 0);
+	_config->Set("APT::Force-LoopBreak", (flags & EIPP::Request::ALLOW_TEMPORARY_REMOVE_OF_ESSENTIALS) != 0);
+
+	EDSP::WriteProgress(5, "Read scenario…", output);
+
+	pkgCacheFile CacheFile;
+	if (CacheFile.Open(NULL, false) == false)
+		DIE("Failed to open CacheFile!");
+
+	EDSP::WriteProgress(50, "Apply request on scenario…", output);
+
+	if (EIPP::ApplyRequest(actions, CacheFile) == false)
+		DIE("Failed to apply request to depcache!");
+
+	EDSP::WriteProgress(60, "Call orderinstall on current scenario…", output);
+
+	//_config->Set("Debug::pkgOrderList", true);
+	//_config->Set("Debug::pkgPackageManager", true);
+	PMOutput PM(CacheFile, output);
+	if (PM.ApplyRequest(actions) == false)
+		DIE("Failed to apply request to packagemanager!");
+	pkgPackageManager::OrderResult const Res = PM.DoInstallPreFork();
+	std::ostringstream broken;
+	switch (Res)
+	{
+	   case pkgPackageManager::Completed:
+	      EDSP::WriteProgress(100, "Done", output);
+	      break;
+	   case pkgPackageManager::Incomplete:
+	      broken << "Planner could only incompletely plan an installation order!" << std::endl;
+	      _error->DumpErrors(broken, GlobalError::DEBUG);
+	      EDSP::WriteError("pm-incomplete", broken.str(), output);
+	      break;
+	   case pkgPackageManager::Failed:
+	      broken << "Planner failed to find an installation order!" << std::endl;
+	      _error->DumpErrors(broken, GlobalError::DEBUG);
+	      EDSP::WriteError("pm-failed", broken.str(), output);
+	      break;
+	}
+
+	return DispatchCommandLine(CmdL, {});
+}
+									/*}}}*/