[apt.git] / apt-private / private-install.h

#ifndef APT_PRIVATE_INSTALL_H
#define APT_PRIVATE_INSTALL_H

#include <apt-pkg/cacheset.h>
#include <apt-pkg/cmndline.h>
#include <apt-pkg/strutl.h>

#include "private-cachefile.h"
#include "private-output.h"

#include <apti18n.h>

#define RAMFS_MAGIC     0x858458f6

bool DoInstall(CommandLine &Cmd);

bool DoCacheManipulationFromCommandLine(CommandLine &CmdL, CacheFile &Cache,
                                        std::map<unsigned short, APT::VersionSet> &verset);
bool DoCacheManipulationFromCommandLine(CommandLine &CmdL, CacheFile &Cache);

bool InstallPackages(CacheFile &Cache,bool ShwKept,bool Ask = true,
                        bool Safety = true);


// TryToInstall - Mark a package for installation			/*{{{*/
struct TryToInstall {
   pkgCacheFile* Cache;
   pkgProblemResolver* Fix;
   bool FixBroken;
   unsigned long AutoMarkChanged;
   APT::PackageSet doAutoInstallLater;

   TryToInstall(pkgCacheFile &Cache, pkgProblemResolver *PM, bool const FixBroken) : Cache(&Cache), Fix(PM),
			FixBroken(FixBroken), AutoMarkChanged(0) {};

   void operator() (pkgCache::VerIterator const &Ver) {
      pkgCache::PkgIterator Pkg = Ver.ParentPkg();

      Cache->GetDepCache()->SetCandidateVersion(Ver);
      pkgDepCache::StateCache &State = (*Cache)[Pkg];

      // Handle the no-upgrade case
      if (_config->FindB("APT::Get::upgrade",true) == false && Pkg->CurrentVer != 0)
	 ioprintf(c1out,_("Skipping %s, it is already installed and upgrade is not set.\n"),
		  Pkg.FullName(true).c_str());
      // Ignore request for install if package would be new
      else if (_config->FindB("APT::Get::Only-Upgrade", false) == true && Pkg->CurrentVer == 0)
	 ioprintf(c1out,_("Skipping %s, it is not installed and only upgrades are requested.\n"),
		  Pkg.FullName(true).c_str());
      else {
	 if (Fix != NULL) {
	    Fix->Clear(Pkg);
	    Fix->Protect(Pkg);
	 }
	 Cache->GetDepCache()->MarkInstall(Pkg,false);

	 if (State.Install() == false) {
	    if (_config->FindB("APT::Get::ReInstall",false) == true) {
	       if (Pkg->CurrentVer == 0 || Pkg.CurrentVer().Downloadable() == false)
		  ioprintf(c1out,_("Reinstallation of %s is not possible, it cannot be downloaded.\n"),
			   Pkg.FullName(true).c_str());
	       else
		  Cache->GetDepCache()->SetReInstall(Pkg, true);
	    } else
	       ioprintf(c1out,_("%s is already the newest version.\n"),
			Pkg.FullName(true).c_str());
	 }

	 // Install it with autoinstalling enabled (if we not respect the minial
	 // required deps or the policy)
	 if (FixBroken == false)
	    doAutoInstallLater.insert(Pkg);
      }

      // see if we need to fix the auto-mark flag
      // e.g. apt-get install foo
      // where foo is marked automatic
      if (State.Install() == false &&
	  (State.Flags & pkgCache::Flag::Auto) &&
	  _config->FindB("APT::Get::ReInstall",false) == false &&
	  _config->FindB("APT::Get::Only-Upgrade",false) == false &&
	  _config->FindB("APT::Get::Download-Only",false) == false)
      {
	 ioprintf(c1out,_("%s set to manually installed.\n"),
		  Pkg.FullName(true).c_str());
	 Cache->GetDepCache()->MarkAuto(Pkg,false);
	 AutoMarkChanged++;
      }
   }

   bool propergateReleaseCandiateSwitching(std::list<std::pair<pkgCache::VerIterator, std::string> > start, std::ostream &out)
   {
      for (std::list<std::pair<pkgCache::VerIterator, std::string> >::const_iterator s = start.begin();
		s != start.end(); ++s)
	 Cache->GetDepCache()->SetCandidateVersion(s->first);

      bool Success = true;
      std::list<std::pair<pkgCache::VerIterator, pkgCache::VerIterator> > Changed;
      for (std::list<std::pair<pkgCache::VerIterator, std::string> >::const_iterator s = start.begin();
		s != start.end(); ++s)
      {
	 Changed.push_back(std::make_pair(s->first, pkgCache::VerIterator(*Cache)));
	 // We continue here even if it failed to enhance the ShowBroken output
	 Success &= Cache->GetDepCache()->SetCandidateRelease(s->first, s->second, Changed);
      }
      for (std::list<std::pair<pkgCache::VerIterator, pkgCache::VerIterator> >::const_iterator c = Changed.begin();
	   c != Changed.end(); ++c)
      {
	 if (c->second.end() == true)
	    ioprintf(out, _("Selected version '%s' (%s) for '%s'\n"),
		     c->first.VerStr(), c->first.RelStr().c_str(), c->first.ParentPkg().FullName(true).c_str());
	 else if (c->first.ParentPkg()->Group != c->second.ParentPkg()->Group)
	 {
	    pkgCache::VerIterator V = (*Cache)[c->first.ParentPkg()].CandidateVerIter(*Cache);
	    ioprintf(out, _("Selected version '%s' (%s) for '%s' because of '%s'\n"), V.VerStr(),
		     V.RelStr().c_str(), V.ParentPkg().FullName(true).c_str(), c->second.ParentPkg().FullName(true).c_str());
	 }
      }
      return Success;
   }

   void doAutoInstall() {
      for (APT::PackageSet::const_iterator P = doAutoInstallLater.begin();
	   P != doAutoInstallLater.end(); ++P) {
	 pkgDepCache::StateCache &State = (*Cache)[P];
	 if (State.InstBroken() == false && State.InstPolicyBroken() == false)
	    continue;
	 Cache->GetDepCache()->MarkInstall(P, true);
      }
      doAutoInstallLater.clear();
   }
};
									/*}}}*/
// TryToRemove - Mark a package for removal				/*{{{*/
struct TryToRemove {
   pkgCacheFile* Cache;
   pkgProblemResolver* Fix;
   bool PurgePkgs;

   TryToRemove(pkgCacheFile &Cache, pkgProblemResolver *PM) : Cache(&Cache), Fix(PM),
				PurgePkgs(_config->FindB("APT::Get::Purge", false)) {};

   void operator() (pkgCache::VerIterator const &Ver)
   {
      pkgCache::PkgIterator Pkg = Ver.ParentPkg();

      if (Fix != NULL)
      {
	 Fix->Clear(Pkg);
	 Fix->Protect(Pkg);
	 Fix->Remove(Pkg);
      }

      if ((Pkg->CurrentVer == 0 && PurgePkgs == false) ||
	  (PurgePkgs == true && Pkg->CurrentState == pkgCache::State::NotInstalled))
      {
	 pkgCache::GrpIterator Grp = Pkg.Group();
	 pkgCache::PkgIterator P = Grp.PackageList();
	 for (; P.end() != true; P = Grp.NextPkg(P))
	 {
	    if (P == Pkg)
	       continue;
	    if (P->CurrentVer != 0 || (PurgePkgs == true && P->CurrentState != pkgCache::State::NotInstalled))
	    {
	       // TRANSLATORS: Note, this is not an interactive question
	       ioprintf(c1out,_("Package '%s' is not installed, so not removed. Did you mean '%s'?\n"),
			Pkg.FullName(true).c_str(), P.FullName(true).c_str());
	       break;
	    }
	 }
	 if (P.end() == true)
	    ioprintf(c1out,_("Package '%s' is not installed, so not removed\n"),Pkg.FullName(true).c_str());

	 // MarkInstall refuses to install packages on hold
	 Pkg->SelectedState = pkgCache::State::Hold;
      }
      else
	 Cache->GetDepCache()->MarkDelete(Pkg, PurgePkgs);
   }
};
									/*}}}*/


#endif
Commit	Line	Data
b9179170 MV	1	#ifndef APT_PRIVATE_INSTALL_H
	2	#define APT_PRIVATE_INSTALL_H
	3
	4	#include <apt-pkg/cacheset.h>
	5	#include <apt-pkg/cmndline.h>
	6	#include <apt-pkg/strutl.h>
	7
	8	#include "private-cachefile.h"
	9	#include "private-output.h"
	10
	11	#include <apti18n.h>
	12
	13	#define RAMFS_MAGIC 0x858458f6
	14
	15	bool DoInstall(CommandLine &Cmd);
	16
d8a8f9d7 MV	17	bool DoCacheManipulationFromCommandLine(CommandLine &CmdL, CacheFile &Cache,
	18	std::map<unsigned short, APT::VersionSet> &verset);
	19	bool DoCacheManipulationFromCommandLine(CommandLine &CmdL, CacheFile &Cache);
b9179170 MV	20
	21	bool InstallPackages(CacheFile &Cache,bool ShwKept,bool Ask = true,
	22	bool Safety = true);
	23
	24
	25	// TryToInstall - Mark a package for installation /{{{/
	26	struct TryToInstall {
	27	pkgCacheFile* Cache;
	28	pkgProblemResolver* Fix;
	29	bool FixBroken;
	30	unsigned long AutoMarkChanged;
	31	APT::PackageSet doAutoInstallLater;
	32
	33	TryToInstall(pkgCacheFile &Cache, pkgProblemResolver *PM, bool const FixBroken) : Cache(&Cache), Fix(PM),
	34	FixBroken(FixBroken), AutoMarkChanged(0) {};
	35
	36	void operator() (pkgCache::VerIterator const &Ver) {
	37	pkgCache::PkgIterator Pkg = Ver.ParentPkg();
	38
	39	Cache->GetDepCache()->SetCandidateVersion(Ver);
	40	pkgDepCache::StateCache &State = (*Cache)[Pkg];
	41
	42	// Handle the no-upgrade case
	43	if (_config->FindB("APT::Get::upgrade",true) == false && Pkg->CurrentVer != 0)
	44	ioprintf(c1out,_("Skipping %s, it is already installed and upgrade is not set.\n"),
	45	Pkg.FullName(true).c_str());
	46	// Ignore request for install if package would be new
	47	else if (_config->FindB("APT::Get::Only-Upgrade", false) == true && Pkg->CurrentVer == 0)
	48	ioprintf(c1out,_("Skipping %s, it is not installed and only upgrades are requested.\n"),
	49	Pkg.FullName(true).c_str());
	50	else {
	51	if (Fix != NULL) {
	52	Fix->Clear(Pkg);
	53	Fix->Protect(Pkg);
	54	}
	55	Cache->GetDepCache()->MarkInstall(Pkg,false);
	56
	57	if (State.Install() == false) {
	58	if (_config->FindB("APT::Get::ReInstall",false) == true) {
	59	if (Pkg->CurrentVer == 0 \|\| Pkg.CurrentVer().Downloadable() == false)
	60	ioprintf(c1out,_("Reinstallation of %s is not possible, it cannot be downloaded.\n"),
	61	Pkg.FullName(true).c_str());
	62	else
	63	Cache->GetDepCache()->SetReInstall(Pkg, true);
	64	} else
	65	ioprintf(c1out,_("%s is already the newest version.\n"),
	66	Pkg.FullName(true).c_str());
	67	}
	68
	69	// Install it with autoinstalling enabled (if we not respect the minial
	70	// required deps or the policy)
	71	if (FixBroken == false)
	72	doAutoInstallLater.insert(Pkg);
	73	}
	74
	75	// see if we need to fix the auto-mark flag
	76	// e.g. apt-get install foo
	77	// where foo is marked automatic
	78	if (State.Install() == false &&
	79	(State.Flags & pkgCache::Flag::Auto) &&
	80	_config->FindB("APT::Get::ReInstall",false) == false &&
	81	_config->FindB("APT::Get::Only-Upgrade",false) == false &&
	82	_config->FindB("APT::Get::Download-Only",false) == false)
	83	{
84	ioprintf(c1out,_("%s set to manually installed.\n"),
85	Pkg.FullName(true).c_str());
86	Cache->GetDepCache()->MarkAuto(Pkg,false);
87	AutoMarkChanged++;
88	}
89	}
90
91	bool propergateReleaseCandiateSwitching(std::list<std::pair<pkgCache::VerIterator, std::string> > start, std::ostream &out)
92	{
93	for (std::list<std::pair<pkgCache::VerIterator, std::string> >::const_iterator s = start.begin();
94	s != start.end(); ++s)
95	Cache->GetDepCache()->SetCandidateVersion(s->first);
96
97	bool Success = true;
98	std::list<std::pair<pkgCache::VerIterator, pkgCache::VerIterator> > Changed;
99	for (std::list<std::pair<pkgCache::VerIterator, std::string> >::const_iterator s = start.begin();
100	s != start.end(); ++s)
101	{
102	Changed.push_back(std::make_pair(s->first, pkgCache::VerIterator(*Cache)));
103	// We continue here even if it failed to enhance the ShowBroken output
104	Success &= Cache->GetDepCache()->SetCandidateRelease(s->first, s->second, Changed);
105	}
106	for (std::list<std::pair<pkgCache::VerIterator, pkgCache::VerIterator> >::const_iterator c = Changed.begin();
107	c != Changed.end(); ++c)
108	{
109	if (c->second.end() == true)
110	ioprintf(out, _("Selected version '%s' (%s) for '%s'\n"),
111	c->first.VerStr(), c->first.RelStr().c_str(), c->first.ParentPkg().FullName(true).c_str());
112	else if (c->first.ParentPkg()->Group != c->second.ParentPkg()->Group)
113	{
114	pkgCache::VerIterator V = (Cache)[c->first.ParentPkg()].CandidateVerIter(Cache);
115	ioprintf(out, _("Selected version '%s' (%s) for '%s' because of '%s'\n"), V.VerStr(),
116	V.RelStr().c_str(), V.ParentPkg().FullName(true).c_str(), c->second.ParentPkg().FullName(true).c_str());
117	}
118	}
119	return Success;
120	}
121
122	void doAutoInstall() {
123	for (APT::PackageSet::const_iterator P = doAutoInstallLater.begin();
124	P != doAutoInstallLater.end(); ++P) {
125	pkgDepCache::StateCache &State = (*Cache)[P];
126	if (State.InstBroken() == false && State.InstPolicyBroken() == false)
127	continue;
128	Cache->GetDepCache()->MarkInstall(P, true);
129	}
130	doAutoInstallLater.clear();
131	}
132	};
133	/}}}/
134	// TryToRemove - Mark a package for removal /{{{/
135	struct TryToRemove {
136	pkgCacheFile* Cache;
137	pkgProblemResolver* Fix;
138	bool PurgePkgs;
139
140	TryToRemove(pkgCacheFile &Cache, pkgProblemResolver *PM) : Cache(&Cache), Fix(PM),
141	PurgePkgs(_config->FindB("APT::Get::Purge", false)) {};
142
143	void operator() (pkgCache::VerIterator const &Ver)
144	{
145	pkgCache::PkgIterator Pkg = Ver.ParentPkg();
146
147	if (Fix != NULL)
148	{
149	Fix->Clear(Pkg);
150	Fix->Protect(Pkg);
151	Fix->Remove(Pkg);
152	}
153
154	if ((Pkg->CurrentVer == 0 && PurgePkgs == false) \|\|
155	(PurgePkgs == true && Pkg->CurrentState == pkgCache::State::NotInstalled))
156	{
157	pkgCache::GrpIterator Grp = Pkg.Group();
158	pkgCache::PkgIterator P = Grp.PackageList();
159	for (; P.end() != true; P = Grp.NextPkg(P))
160	{
161	if (P == Pkg)
162	continue;
163	if (P->CurrentVer != 0 \|\| (PurgePkgs == true && P->CurrentState != pkgCache::State::NotInstalled))
164	{
165	// TRANSLATORS: Note, this is not an interactive question
166	ioprintf(c1out,_("Package '%s' is not installed, so not removed. Did you mean '%s'?\n"),
167	Pkg.FullName(true).c_str(), P.FullName(true).c_str());
168	break;
169	}
170	}
171	if (P.end() == true)
172	ioprintf(c1out,_("Package '%s' is not installed, so not removed\n"),Pkg.FullName(true).c_str());
173
174	// MarkInstall refuses to install packages on hold
175	Pkg->SelectedState = pkgCache::State::Hold;
176	}
177	else
178	Cache->GetDepCache()->MarkDelete(Pkg, PurgePkgs);
179	}
180	};
181	/}}}/
182
183
184	#endif