]>
Commit | Line | Data |
---|---|---|
6c139d6e AL |
1 | // -*- mode: cpp; mode: fold -*- |
2 | // Description /*{{{*/ | |
b8c0f9b7 | 3 | // $Id: algorithms.cc,v 1.44 2002/11/28 18:49:16 jgg Exp $ |
6c139d6e AL |
4 | /* ###################################################################### |
5 | ||
6 | Algorithms - A set of misc algorithms | |
7 | ||
0a8e3465 AL |
8 | The pkgProblemResolver class has become insanely complex and |
9 | very sophisticated, it handles every test case I have thrown at it | |
10 | to my satisfaction. Understanding exactly why all the steps the class | |
11 | does are required is difficult and changing though not very risky | |
12 | may result in other cases not working. | |
13 | ||
6c139d6e AL |
14 | ##################################################################### */ |
15 | /*}}}*/ | |
16 | // Include Files /*{{{*/ | |
ea542140 DK |
17 | #include <config.h> |
18 | ||
094a497d AL |
19 | #include <apt-pkg/algorithms.h> |
20 | #include <apt-pkg/error.h> | |
0a8e3465 | 21 | #include <apt-pkg/configuration.h> |
0a57c0f0 | 22 | #include <apt-pkg/version.h> |
b2e465d6 | 23 | #include <apt-pkg/sptr.h> |
760d4968 | 24 | #include <apt-pkg/acquire-item.h> |
c3b85126 | 25 | #include <apt-pkg/edsp.h> |
472ff00e DK |
26 | #include <apt-pkg/sourcelist.h> |
27 | #include <apt-pkg/fileutl.h> | |
28 | #include <apt-pkg/progress.h> | |
6d38011b | 29 | |
22dcc318 | 30 | #include <sys/types.h> |
152ab79e MV |
31 | #include <cstdlib> |
32 | #include <algorithm> | |
90f057fd | 33 | #include <iostream> |
6d38011b | 34 | #include <stdio.h> |
ea542140 DK |
35 | |
36 | #include <apti18n.h> | |
6c139d6e | 37 | /*}}}*/ |
584e4558 | 38 | using namespace std; |
6c139d6e AL |
39 | |
40 | pkgProblemResolver *pkgProblemResolver::This = 0; | |
41 | ||
42 | // Simulate::Simulate - Constructor /*{{{*/ | |
43 | // --------------------------------------------------------------------- | |
b2e465d6 AL |
44 | /* The legacy translations here of input Pkg iterators is obsolete, |
45 | this is not necessary since the pkgCaches are fully shared now. */ | |
46 | pkgSimulate::pkgSimulate(pkgDepCache *Cache) : pkgPackageManager(Cache), | |
47 | iPolicy(Cache), | |
496d5c70 MV |
48 | Sim(&Cache->GetCache(),&iPolicy), |
49 | group(Sim) | |
6c139d6e | 50 | { |
b2e465d6 AL |
51 | Sim.Init(0); |
52 | Flags = new unsigned char[Cache->Head().PackageCount]; | |
53 | memset(Flags,0,sizeof(*Flags)*Cache->Head().PackageCount); | |
281daf46 AL |
54 | |
55 | // Fake a filename so as not to activate the media swapping | |
56 | string Jnk = "SIMULATE"; | |
b2e465d6 | 57 | for (unsigned int I = 0; I != Cache->Head().PackageCount; I++) |
281daf46 | 58 | FileNames[I] = Jnk; |
6c139d6e AL |
59 | } |
60 | /*}}}*/ | |
b270388b MV |
61 | // Simulate::~Simulate - Destructor /*{{{*/ |
62 | pkgSimulate::~pkgSimulate() | |
63 | { | |
64 | delete[] Flags; | |
65 | } | |
66 | /*}}}*/ | |
b2e465d6 AL |
67 | // Simulate::Describe - Describe a package /*{{{*/ |
68 | // --------------------------------------------------------------------- | |
3826564e MZ |
69 | /* Parameter Current == true displays the current package version, |
70 | Parameter Candidate == true displays the candidate package version */ | |
71 | void pkgSimulate::Describe(PkgIterator Pkg,ostream &out,bool Current,bool Candidate) | |
b2e465d6 AL |
72 | { |
73 | VerIterator Ver(Sim); | |
e59458f7 | 74 | |
47f6d1b7 | 75 | out << Pkg.FullName(true); |
e59458f7 | 76 | |
3826564e | 77 | if (Current == true) |
e59458f7 | 78 | { |
b2e465d6 | 79 | Ver = Pkg.CurrentVer(); |
e59458f7 AL |
80 | if (Ver.end() == false) |
81 | out << " [" << Ver.VerStr() << ']'; | |
82 | } | |
b2e465d6 | 83 | |
3826564e MZ |
84 | if (Candidate == true) |
85 | { | |
86 | Ver = Sim[Pkg].CandidateVerIter(Sim); | |
87 | if (Ver.end() == true) | |
88 | return; | |
b2e465d6 | 89 | |
3826564e MZ |
90 | out << " (" << Ver.VerStr() << ' ' << Ver.RelStr() << ')'; |
91 | } | |
b2e465d6 AL |
92 | } |
93 | /*}}}*/ | |
6c139d6e AL |
94 | // Simulate::Install - Simulate unpacking of a package /*{{{*/ |
95 | // --------------------------------------------------------------------- | |
96 | /* */ | |
97 | bool pkgSimulate::Install(PkgIterator iPkg,string /*File*/) | |
98 | { | |
99 | // Adapt the iterator | |
803ea2a8 | 100 | PkgIterator Pkg = Sim.FindPkg(iPkg.Name(), iPkg.Arch()); |
6c139d6e AL |
101 | Flags[Pkg->ID] = 1; |
102 | ||
b2e465d6 | 103 | cout << "Inst "; |
3826564e | 104 | Describe(Pkg,cout,true,true); |
6c139d6e | 105 | Sim.MarkInstall(Pkg,false); |
803ea2a8 | 106 | |
6c139d6e | 107 | // Look for broken conflicts+predepends. |
f7f0d6c7 | 108 | for (PkgIterator I = Sim.PkgBegin(); I.end() == false; ++I) |
6c139d6e AL |
109 | { |
110 | if (Sim[I].InstallVer == 0) | |
111 | continue; | |
112 | ||
b2e465d6 AL |
113 | for (DepIterator D = Sim[I].InstVerIter(Sim).DependsList(); D.end() == false;) |
114 | { | |
115 | DepIterator Start; | |
116 | DepIterator End; | |
117 | D.GlobOr(Start,End); | |
359e46db | 118 | if (Start.IsNegative() == true || |
b2e465d6 | 119 | End->Type == pkgCache::Dep::PreDepends) |
6c139d6e | 120 | { |
b2e465d6 | 121 | if ((Sim[End] & pkgDepCache::DepGInstall) == 0) |
6c139d6e | 122 | { |
47f6d1b7 | 123 | cout << " [" << I.FullName(false) << " on " << Start.TargetPkg().FullName(false) << ']'; |
b2e465d6 | 124 | if (Start->Type == pkgCache::Dep::Conflicts) |
47f6d1b7 | 125 | _error->Error("Fatal, conflicts violated %s",I.FullName(false).c_str()); |
6c139d6e | 126 | } |
b2e465d6 AL |
127 | } |
128 | } | |
6c139d6e AL |
129 | } |
130 | ||
131 | if (Sim.BrokenCount() != 0) | |
132 | ShortBreaks(); | |
133 | else | |
04aa15a8 | 134 | cout << endl; |
6c139d6e AL |
135 | return true; |
136 | } | |
137 | /*}}}*/ | |
138 | // Simulate::Configure - Simulate configuration of a Package /*{{{*/ | |
139 | // --------------------------------------------------------------------- | |
140 | /* This is not an acurate simulation of relatity, we should really not | |
141 | install the package.. For some investigations it may be necessary | |
142 | however. */ | |
143 | bool pkgSimulate::Configure(PkgIterator iPkg) | |
144 | { | |
145 | // Adapt the iterator | |
803ea2a8 | 146 | PkgIterator Pkg = Sim.FindPkg(iPkg.Name(), iPkg.Arch()); |
6c139d6e AL |
147 | |
148 | Flags[Pkg->ID] = 2; | |
803ea2a8 | 149 | |
6c139d6e AL |
150 | if (Sim[Pkg].InstBroken() == true) |
151 | { | |
47f6d1b7 | 152 | cout << "Conf " << Pkg.FullName(false) << " broken" << endl; |
6c139d6e AL |
153 | |
154 | Sim.Update(); | |
155 | ||
156 | // Print out each package and the failed dependencies | |
f7f0d6c7 | 157 | for (pkgCache::DepIterator D = Sim[Pkg].InstVerIter(Sim).DependsList(); D.end() == false; ++D) |
6c139d6e AL |
158 | { |
159 | if (Sim.IsImportantDep(D) == false || | |
160 | (Sim[D] & pkgDepCache::DepInstall) != 0) | |
161 | continue; | |
162 | ||
b2e465d6 | 163 | if (D->Type == pkgCache::Dep::Obsoletes) |
47f6d1b7 | 164 | cout << " Obsoletes:" << D.TargetPkg().FullName(false); |
b2e465d6 | 165 | else if (D->Type == pkgCache::Dep::Conflicts) |
47f6d1b7 | 166 | cout << " Conflicts:" << D.TargetPkg().FullName(false); |
308c7d30 | 167 | else if (D->Type == pkgCache::Dep::DpkgBreaks) |
47f6d1b7 | 168 | cout << " Breaks:" << D.TargetPkg().FullName(false); |
6c139d6e | 169 | else |
47f6d1b7 | 170 | cout << " Depends:" << D.TargetPkg().FullName(false); |
6c139d6e | 171 | } |
04aa15a8 | 172 | cout << endl; |
6c139d6e | 173 | |
09a10f9c | 174 | _error->Error("Conf Broken %s",Pkg.FullName(false).c_str()); |
6c139d6e AL |
175 | } |
176 | else | |
b2e465d6 AL |
177 | { |
178 | cout << "Conf "; | |
3826564e | 179 | Describe(Pkg,cout,false,true); |
b2e465d6 | 180 | } |
6c139d6e AL |
181 | |
182 | if (Sim.BrokenCount() != 0) | |
183 | ShortBreaks(); | |
184 | else | |
04aa15a8 | 185 | cout << endl; |
6c139d6e AL |
186 | |
187 | return true; | |
188 | } | |
189 | /*}}}*/ | |
190 | // Simulate::Remove - Simulate the removal of a package /*{{{*/ | |
191 | // --------------------------------------------------------------------- | |
192 | /* */ | |
fc4b5c9f | 193 | bool pkgSimulate::Remove(PkgIterator iPkg,bool Purge) |
6c139d6e AL |
194 | { |
195 | // Adapt the iterator | |
803ea2a8 | 196 | PkgIterator Pkg = Sim.FindPkg(iPkg.Name(), iPkg.Arch()); |
c919ad6e DK |
197 | if (Pkg.end() == true) |
198 | { | |
199 | std::cerr << (Purge ? "Purg" : "Remv") << " invalid package " << iPkg.FullName() << std::endl; | |
200 | return false; | |
201 | } | |
6c139d6e AL |
202 | |
203 | Flags[Pkg->ID] = 3; | |
204 | Sim.MarkDelete(Pkg); | |
803ea2a8 | 205 | |
fc4b5c9f | 206 | if (Purge == true) |
b2e465d6 | 207 | cout << "Purg "; |
fc4b5c9f | 208 | else |
b2e465d6 | 209 | cout << "Remv "; |
3826564e | 210 | Describe(Pkg,cout,true,false); |
6c139d6e AL |
211 | |
212 | if (Sim.BrokenCount() != 0) | |
213 | ShortBreaks(); | |
214 | else | |
04aa15a8 | 215 | cout << endl; |
6c139d6e AL |
216 | |
217 | return true; | |
218 | } | |
219 | /*}}}*/ | |
220 | // Simulate::ShortBreaks - Print out a short line describing all breaks /*{{{*/ | |
221 | // --------------------------------------------------------------------- | |
222 | /* */ | |
223 | void pkgSimulate::ShortBreaks() | |
224 | { | |
04aa15a8 | 225 | cout << " ["; |
f7f0d6c7 | 226 | for (PkgIterator I = Sim.PkgBegin(); I.end() == false; ++I) |
6c139d6e AL |
227 | { |
228 | if (Sim[I].InstBroken() == true) | |
229 | { | |
230 | if (Flags[I->ID] == 0) | |
47f6d1b7 | 231 | cout << I.FullName(false) << ' '; |
6c139d6e | 232 | /* else |
04aa15a8 | 233 | cout << I.Name() << "! ";*/ |
6c139d6e AL |
234 | } |
235 | } | |
04aa15a8 | 236 | cout << ']' << endl; |
6c139d6e AL |
237 | } |
238 | /*}}}*/ | |
239 | // ApplyStatus - Adjust for non-ok packages /*{{{*/ | |
240 | // --------------------------------------------------------------------- | |
241 | /* We attempt to change the state of the all packages that have failed | |
242 | installation toward their real state. The ordering code will perform | |
243 | the necessary calculations to deal with the problems. */ | |
244 | bool pkgApplyStatus(pkgDepCache &Cache) | |
245 | { | |
74a05226 MV |
246 | pkgDepCache::ActionGroup group(Cache); |
247 | ||
f7f0d6c7 | 248 | for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I) |
6c139d6e | 249 | { |
e481d5b0 AL |
250 | if (I->VersionList == 0) |
251 | continue; | |
252 | ||
d38b7b3d AL |
253 | // Only choice for a ReInstReq package is to reinstall |
254 | if (I->InstState == pkgCache::State::ReInstReq || | |
255 | I->InstState == pkgCache::State::HoldReInstReq) | |
256 | { | |
5871718b | 257 | if (I->CurrentVer != 0 && I.CurrentVer().Downloadable() == true) |
74a05226 | 258 | Cache.MarkKeep(I, false, false); |
813c8eea AL |
259 | else |
260 | { | |
261 | // Is this right? Will dpkg choke on an upgrade? | |
2a3f3893 AL |
262 | if (Cache[I].CandidateVer != 0 && |
263 | Cache[I].CandidateVerIter(Cache).Downloadable() == true) | |
74a05226 | 264 | Cache.MarkInstall(I, false, 0, false); |
813c8eea | 265 | else |
b2e465d6 | 266 | return _error->Error(_("The package %s needs to be reinstalled, " |
09a10f9c | 267 | "but I can't find an archive for it."),I.FullName(true).c_str()); |
813c8eea AL |
268 | } |
269 | ||
d38b7b3d AL |
270 | continue; |
271 | } | |
272 | ||
6c139d6e AL |
273 | switch (I->CurrentState) |
274 | { | |
813c8eea AL |
275 | /* This means installation failed somehow - it does not need to be |
276 | re-unpacked (probably) */ | |
b518cca6 AL |
277 | case pkgCache::State::UnPacked: |
278 | case pkgCache::State::HalfConfigured: | |
9d06bc80 MV |
279 | case pkgCache::State::TriggersAwaited: |
280 | case pkgCache::State::TriggersPending: | |
5871718b | 281 | if ((I->CurrentVer != 0 && I.CurrentVer().Downloadable() == true) || |
813c8eea | 282 | I.State() != pkgCache::PkgIterator::NeedsUnpack) |
74a05226 | 283 | Cache.MarkKeep(I, false, false); |
813c8eea AL |
284 | else |
285 | { | |
2a3f3893 AL |
286 | if (Cache[I].CandidateVer != 0 && |
287 | Cache[I].CandidateVerIter(Cache).Downloadable() == true) | |
74a05226 | 288 | Cache.MarkInstall(I, true, 0, false); |
813c8eea | 289 | else |
b83cad32 | 290 | Cache.MarkDelete(I, false, 0, false); |
813c8eea | 291 | } |
6c139d6e AL |
292 | break; |
293 | ||
294 | // This means removal failed | |
b518cca6 | 295 | case pkgCache::State::HalfInstalled: |
b83cad32 | 296 | Cache.MarkDelete(I, false, 0, false); |
6c139d6e AL |
297 | break; |
298 | ||
299 | default: | |
b518cca6 | 300 | if (I->InstState != pkgCache::State::Ok) |
6c139d6e | 301 | return _error->Error("The package %s is not ok and I " |
09a10f9c | 302 | "don't know how to fix it!",I.FullName(false).c_str()); |
6c139d6e AL |
303 | } |
304 | } | |
305 | return true; | |
306 | } | |
307 | /*}}}*/ | |
308 | // FixBroken - Fix broken packages /*{{{*/ | |
309 | // --------------------------------------------------------------------- | |
0a8e3465 AL |
310 | /* This autoinstalls every broken package and then runs the problem resolver |
311 | on the result. */ | |
6c139d6e AL |
312 | bool pkgFixBroken(pkgDepCache &Cache) |
313 | { | |
74a05226 MV |
314 | pkgDepCache::ActionGroup group(Cache); |
315 | ||
6c139d6e | 316 | // Auto upgrade all broken packages |
f7f0d6c7 | 317 | for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I) |
6c139d6e | 318 | if (Cache[I].NowBroken() == true) |
74a05226 | 319 | Cache.MarkInstall(I, true, 0, false); |
7e798dd7 | 320 | |
6c139d6e AL |
321 | /* Fix packages that are in a NeedArchive state but don't have a |
322 | downloadable install version */ | |
f7f0d6c7 | 323 | for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I) |
6c139d6e AL |
324 | { |
325 | if (I.State() != pkgCache::PkgIterator::NeedsUnpack || | |
326 | Cache[I].Delete() == true) | |
327 | continue; | |
328 | ||
b518cca6 | 329 | if (Cache[I].InstVerIter(Cache).Downloadable() == false) |
6c139d6e AL |
330 | continue; |
331 | ||
74a05226 | 332 | Cache.MarkInstall(I, true, 0, false); |
6c139d6e AL |
333 | } |
334 | ||
b2e465d6 | 335 | pkgProblemResolver Fix(&Cache); |
6c139d6e AL |
336 | return Fix.Resolve(true); |
337 | } | |
338 | /*}}}*/ | |
339 | // DistUpgrade - Distribution upgrade /*{{{*/ | |
340 | // --------------------------------------------------------------------- | |
341 | /* This autoinstalls every package and then force installs every | |
342 | pre-existing package. This creates the initial set of conditions which | |
343 | most likely contain problems because too many things were installed. | |
344 | ||
0a8e3465 | 345 | The problem resolver is used to resolve the problems. |
6c139d6e AL |
346 | */ |
347 | bool pkgDistUpgrade(pkgDepCache &Cache) | |
348 | { | |
98278a81 | 349 | std::string const solver = _config->Find("APT::Solver", "internal"); |
b57c0e35 DK |
350 | if (solver != "internal") { |
351 | OpTextProgress Prog(*_config); | |
352 | return EDSP::ResolveExternal(solver.c_str(), Cache, false, true, false, &Prog); | |
353 | } | |
741b7da9 | 354 | |
74a05226 MV |
355 | pkgDepCache::ActionGroup group(Cache); |
356 | ||
c427b1e2 DK |
357 | /* Upgrade all installed packages first without autoinst to help the resolver |
358 | in versioned or-groups to upgrade the old solver instead of installing | |
359 | a new one (if the old solver is not the first one [anymore]) */ | |
360 | for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I) | |
361 | if (I->CurrentVer != 0) | |
362 | Cache.MarkInstall(I, false, 0, false); | |
363 | ||
6c139d6e AL |
364 | /* Auto upgrade all installed packages, this provides the basis |
365 | for the installation */ | |
f7f0d6c7 | 366 | for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I) |
6c139d6e | 367 | if (I->CurrentVer != 0) |
74a05226 | 368 | Cache.MarkInstall(I, true, 0, false); |
6c139d6e | 369 | |
e5a91f7e DK |
370 | /* Now, install each essential package which is not installed |
371 | (and not provided by another package in the same name group) */ | |
372 | std::string essential = _config->Find("pkgCacheGen::Essential", "all"); | |
373 | if (essential == "all") | |
374 | { | |
375 | for (pkgCache::GrpIterator G = Cache.GrpBegin(); G.end() == false; ++G) | |
376 | { | |
377 | bool isEssential = false; | |
378 | bool instEssential = false; | |
379 | for (pkgCache::PkgIterator P = G.PackageList(); P.end() == false; P = G.NextPkg(P)) | |
380 | { | |
381 | if ((P->Flags & pkgCache::Flag::Essential) != pkgCache::Flag::Essential) | |
382 | continue; | |
383 | isEssential = true; | |
384 | if (Cache[P].Install() == true) | |
385 | { | |
386 | instEssential = true; | |
387 | break; | |
388 | } | |
389 | } | |
390 | if (isEssential == false || instEssential == true) | |
391 | continue; | |
392 | pkgCache::PkgIterator P = G.FindPreferredPkg(); | |
393 | Cache.MarkInstall(P, true, 0, false); | |
394 | } | |
395 | } | |
396 | else if (essential != "none") | |
397 | for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I) | |
398 | if ((I->Flags & pkgCache::Flag::Essential) == pkgCache::Flag::Essential) | |
399 | Cache.MarkInstall(I, true, 0, false); | |
6c139d6e AL |
400 | |
401 | /* We do it again over all previously installed packages to force | |
402 | conflict resolution on them all. */ | |
f7f0d6c7 | 403 | for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I) |
6c139d6e | 404 | if (I->CurrentVer != 0) |
74a05226 | 405 | Cache.MarkInstall(I, false, 0, false); |
6c139d6e | 406 | |
b2e465d6 | 407 | pkgProblemResolver Fix(&Cache); |
c88edf1d | 408 | |
6c139d6e | 409 | // Hold back held packages. |
4490f2de | 410 | if (_config->FindB("APT::Ignore-Hold",false) == false) |
6c139d6e | 411 | { |
f7f0d6c7 | 412 | for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I) |
6c139d6e | 413 | { |
c88edf1d AL |
414 | if (I->SelectedState == pkgCache::State::Hold) |
415 | { | |
416 | Fix.Protect(I); | |
74a05226 | 417 | Cache.MarkKeep(I, false, false); |
c88edf1d | 418 | } |
6c139d6e AL |
419 | } |
420 | } | |
421 | ||
422 | return Fix.Resolve(); | |
423 | } | |
424 | /*}}}*/ | |
0a8e3465 AL |
425 | // AllUpgrade - Upgrade as many packages as possible /*{{{*/ |
426 | // --------------------------------------------------------------------- | |
427 | /* Right now the system must be consistent before this can be called. | |
428 | It also will not change packages marked for install, it only tries | |
429 | to install packages not marked for install */ | |
430 | bool pkgAllUpgrade(pkgDepCache &Cache) | |
431 | { | |
98278a81 | 432 | std::string const solver = _config->Find("APT::Solver", "internal"); |
b57c0e35 DK |
433 | if (solver != "internal") { |
434 | OpTextProgress Prog(*_config); | |
435 | return EDSP::ResolveExternal(solver.c_str(), Cache, true, false, false, &Prog); | |
436 | } | |
741b7da9 | 437 | |
74a05226 MV |
438 | pkgDepCache::ActionGroup group(Cache); |
439 | ||
b2e465d6 | 440 | pkgProblemResolver Fix(&Cache); |
0a8e3465 AL |
441 | |
442 | if (Cache.BrokenCount() != 0) | |
443 | return false; | |
444 | ||
445 | // Upgrade all installed packages | |
f7f0d6c7 | 446 | for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I) |
0a8e3465 AL |
447 | { |
448 | if (Cache[I].Install() == true) | |
449 | Fix.Protect(I); | |
450 | ||
b2e465d6 | 451 | if (_config->FindB("APT::Ignore-Hold",false) == false) |
c88edf1d AL |
452 | if (I->SelectedState == pkgCache::State::Hold) |
453 | continue; | |
0a8e3465 AL |
454 | |
455 | if (I->CurrentVer != 0 && Cache[I].InstallVer != 0) | |
74a05226 | 456 | Cache.MarkInstall(I, false, 0, false); |
0a8e3465 AL |
457 | } |
458 | ||
459 | return Fix.ResolveByKeep(); | |
460 | } | |
461 | /*}}}*/ | |
7e798dd7 AL |
462 | // MinimizeUpgrade - Minimizes the set of packages to be upgraded /*{{{*/ |
463 | // --------------------------------------------------------------------- | |
464 | /* This simply goes over the entire set of packages and tries to keep | |
465 | each package marked for upgrade. If a conflict is generated then | |
466 | the package is restored. */ | |
467 | bool pkgMinimizeUpgrade(pkgDepCache &Cache) | |
468 | { | |
74a05226 MV |
469 | pkgDepCache::ActionGroup group(Cache); |
470 | ||
7e798dd7 AL |
471 | if (Cache.BrokenCount() != 0) |
472 | return false; | |
473 | ||
abc8419e | 474 | // We loop for 10 tries to get the minimal set size. |
7e798dd7 | 475 | bool Change = false; |
a005475e | 476 | unsigned int Count = 0; |
7e798dd7 AL |
477 | do |
478 | { | |
479 | Change = false; | |
f7f0d6c7 | 480 | for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I) |
7e798dd7 AL |
481 | { |
482 | // Not interesting | |
483 | if (Cache[I].Upgrade() == false || Cache[I].NewInstall() == true) | |
484 | continue; | |
a005475e | 485 | |
7e798dd7 | 486 | // Keep it and see if that is OK |
74a05226 | 487 | Cache.MarkKeep(I, false, false); |
7e798dd7 | 488 | if (Cache.BrokenCount() != 0) |
74a05226 | 489 | Cache.MarkInstall(I, false, 0, false); |
7e798dd7 | 490 | else |
a005475e AL |
491 | { |
492 | // If keep didnt actually do anything then there was no change.. | |
493 | if (Cache[I].Upgrade() == false) | |
494 | Change = true; | |
495 | } | |
7e798dd7 | 496 | } |
f7f0d6c7 | 497 | ++Count; |
7e798dd7 | 498 | } |
a005475e | 499 | while (Change == true && Count < 10); |
7e798dd7 AL |
500 | |
501 | if (Cache.BrokenCount() != 0) | |
502 | return _error->Error("Internal Error in pkgMinimizeUpgrade"); | |
503 | ||
504 | return true; | |
505 | } | |
506 | /*}}}*/ | |
6c139d6e AL |
507 | // ProblemResolver::pkgProblemResolver - Constructor /*{{{*/ |
508 | // --------------------------------------------------------------------- | |
509 | /* */ | |
dcaa1185 | 510 | pkgProblemResolver::pkgProblemResolver(pkgDepCache *pCache) : d(NULL), Cache(*pCache) |
6c139d6e AL |
511 | { |
512 | // Allocate memory | |
b2e465d6 | 513 | unsigned long Size = Cache.Head().PackageCount; |
d0f2c87c | 514 | Scores = new int[Size]; |
6c139d6e AL |
515 | Flags = new unsigned char[Size]; |
516 | memset(Flags,0,sizeof(*Flags)*Size); | |
517 | ||
518 | // Set debug to true to see its decision logic | |
0a8e3465 | 519 | Debug = _config->FindB("Debug::pkgProblemResolver",false); |
6c139d6e AL |
520 | } |
521 | /*}}}*/ | |
b2e465d6 AL |
522 | // ProblemResolver::~pkgProblemResolver - Destructor /*{{{*/ |
523 | // --------------------------------------------------------------------- | |
524 | /* */ | |
525 | pkgProblemResolver::~pkgProblemResolver() | |
526 | { | |
527 | delete [] Scores; | |
528 | delete [] Flags; | |
529 | } | |
530 | /*}}}*/ | |
6c139d6e AL |
531 | // ProblemResolver::ScoreSort - Sort the list by score /*{{{*/ |
532 | // --------------------------------------------------------------------- | |
533 | /* */ | |
534 | int pkgProblemResolver::ScoreSort(const void *a,const void *b) | |
535 | { | |
536 | Package const **A = (Package const **)a; | |
537 | Package const **B = (Package const **)b; | |
538 | if (This->Scores[(*A)->ID] > This->Scores[(*B)->ID]) | |
539 | return -1; | |
540 | if (This->Scores[(*A)->ID] < This->Scores[(*B)->ID]) | |
541 | return 1; | |
542 | return 0; | |
543 | } | |
544 | /*}}}*/ | |
545 | // ProblemResolver::MakeScores - Make the score table /*{{{*/ | |
546 | // --------------------------------------------------------------------- | |
547 | /* */ | |
548 | void pkgProblemResolver::MakeScores() | |
549 | { | |
b2e465d6 | 550 | unsigned long Size = Cache.Head().PackageCount; |
6c139d6e AL |
551 | memset(Scores,0,sizeof(*Scores)*Size); |
552 | ||
9005f08e MV |
553 | // maps to pkgCache::State::VerPriority: |
554 | // Required Important Standard Optional Extra | |
d0f2c87c | 555 | int PrioMap[] = { |
8b4894fe | 556 | 0, |
84de0cea | 557 | _config->FindI("pkgProblemResolver::Scores::Required",3), |
9005f08e | 558 | _config->FindI("pkgProblemResolver::Scores::Important",2), |
d0f2c87c CW |
559 | _config->FindI("pkgProblemResolver::Scores::Standard",1), |
560 | _config->FindI("pkgProblemResolver::Scores::Optional",-1), | |
561 | _config->FindI("pkgProblemResolver::Scores::Extra",-2) | |
8b4894fe | 562 | }; |
d0f2c87c CW |
563 | int PrioEssentials = _config->FindI("pkgProblemResolver::Scores::Essentials",100); |
564 | int PrioInstalledAndNotObsolete = _config->FindI("pkgProblemResolver::Scores::NotObsolete",1); | |
565 | int PrioDepends = _config->FindI("pkgProblemResolver::Scores::Depends",1); | |
566 | int PrioRecommends = _config->FindI("pkgProblemResolver::Scores::Recommends",1); | |
567 | int AddProtected = _config->FindI("pkgProblemResolver::Scores::AddProtected",10000); | |
568 | int AddEssential = _config->FindI("pkgProblemResolver::Scores::AddEssential",5000); | |
8b4894fe MV |
569 | |
570 | if (_config->FindB("Debug::pkgProblemResolver::ShowScores",false) == true) | |
571 | clog << "Settings used to calculate pkgProblemResolver::Scores::" << endl | |
84de0cea MV |
572 | << " Required => " << PrioMap[pkgCache::State::Required] << endl |
573 | << " Important => " << PrioMap[pkgCache::State::Important] << endl | |
574 | << " Standard => " << PrioMap[pkgCache::State::Standard] << endl | |
575 | << " Optional => " << PrioMap[pkgCache::State::Optional] << endl | |
576 | << " Extra => " << PrioMap[pkgCache::State::Extra] << endl | |
8b4894fe MV |
577 | << " Essentials => " << PrioEssentials << endl |
578 | << " InstalledAndNotObsolete => " << PrioInstalledAndNotObsolete << endl | |
579 | << " Depends => " << PrioDepends << endl | |
53391d0f | 580 | << " Recommends => " << PrioRecommends << endl |
8b4894fe MV |
581 | << " AddProtected => " << AddProtected << endl |
582 | << " AddEssential => " << AddEssential << endl; | |
583 | ||
6c139d6e | 584 | // Generate the base scores for a package based on its properties |
f7f0d6c7 | 585 | for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I) |
6c139d6e AL |
586 | { |
587 | if (Cache[I].InstallVer == 0) | |
588 | continue; | |
589 | ||
d0f2c87c | 590 | int &Score = Scores[I->ID]; |
6c139d6e | 591 | |
7365ff46 | 592 | /* This is arbitrary, it should be high enough to elevate an |
6c139d6e AL |
593 | essantial package above most other packages but low enough |
594 | to allow an obsolete essential packages to be removed by | |
595 | a conflicts on a powerfull normal package (ie libc6) */ | |
c5200869 JAK |
596 | if ((I->Flags & pkgCache::Flag::Essential) == pkgCache::Flag::Essential |
597 | || (I->Flags & pkgCache::Flag::Important) == pkgCache::Flag::Important) | |
8b4894fe | 598 | Score += PrioEssentials; |
6c139d6e AL |
599 | |
600 | // We transform the priority | |
6c139d6e AL |
601 | if (Cache[I].InstVerIter(Cache)->Priority <= 5) |
602 | Score += PrioMap[Cache[I].InstVerIter(Cache)->Priority]; | |
603 | ||
604 | /* This helps to fix oddball problems with conflicting packages | |
4172c784 MV |
605 | on the same level. We enhance the score of installed packages |
606 | if those are not obsolete | |
607 | */ | |
020daa7b | 608 | if (I->CurrentVer != 0 && Cache[I].CandidateVer != 0 && Cache[I].CandidateVerIter(Cache).Downloadable()) |
8b4894fe | 609 | Score += PrioInstalledAndNotObsolete; |
6c139d6e AL |
610 | } |
611 | ||
612 | // Now that we have the base scores we go and propogate dependencies | |
f7f0d6c7 | 613 | for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I) |
6c139d6e AL |
614 | { |
615 | if (Cache[I].InstallVer == 0) | |
616 | continue; | |
617 | ||
f7f0d6c7 | 618 | for (pkgCache::DepIterator D = Cache[I].InstVerIter(Cache).DependsList(); D.end() == false; ++D) |
6c139d6e | 619 | { |
3a998f6a | 620 | if (D->Type == pkgCache::Dep::Depends || |
53391d0f MV |
621 | D->Type == pkgCache::Dep::PreDepends) |
622 | Scores[D.TargetPkg()->ID] += PrioDepends; | |
623 | else if (D->Type == pkgCache::Dep::Recommends) | |
624 | Scores[D.TargetPkg()->ID] += PrioRecommends; | |
6c139d6e AL |
625 | } |
626 | } | |
627 | ||
628 | // Copy the scores to advoid additive looping | |
d0f2c87c | 629 | SPtrArray<int> OldScores = new int[Size]; |
6c139d6e AL |
630 | memcpy(OldScores,Scores,sizeof(*Scores)*Size); |
631 | ||
632 | /* Now we cause 1 level of dependency inheritance, that is we add the | |
633 | score of the packages that depend on the target Package. This | |
634 | fortifies high scoring packages */ | |
f7f0d6c7 | 635 | for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I) |
6c139d6e AL |
636 | { |
637 | if (Cache[I].InstallVer == 0) | |
638 | continue; | |
639 | ||
f7f0d6c7 | 640 | for (pkgCache::DepIterator D = I.RevDependsList(); D.end() == false; ++D) |
6c139d6e AL |
641 | { |
642 | // Only do it for the install version | |
643 | if ((pkgCache::Version *)D.ParentVer() != Cache[D.ParentPkg()].InstallVer || | |
3a998f6a MV |
644 | (D->Type != pkgCache::Dep::Depends && |
645 | D->Type != pkgCache::Dep::PreDepends && | |
646 | D->Type != pkgCache::Dep::Recommends)) | |
6c139d6e AL |
647 | continue; |
648 | ||
dec5b117 MV |
649 | // Do not propagate negative scores otherwise |
650 | // an extra (-2) package might score better than an optional (-1) | |
651 | if (OldScores[D.ParentPkg()->ID] > 0) | |
652 | Scores[I->ID] += OldScores[D.ParentPkg()->ID]; | |
6c139d6e AL |
653 | } |
654 | } | |
655 | ||
656 | /* Now we propogate along provides. This makes the packages that | |
657 | provide important packages extremely important */ | |
f7f0d6c7 | 658 | for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I) |
6c139d6e | 659 | { |
f7f0d6c7 | 660 | for (pkgCache::PrvIterator P = I.ProvidesList(); P.end() == false; ++P) |
6c139d6e AL |
661 | { |
662 | // Only do it once per package | |
663 | if ((pkgCache::Version *)P.OwnerVer() != Cache[P.OwnerPkg()].InstallVer) | |
664 | continue; | |
665 | Scores[P.OwnerPkg()->ID] += abs(Scores[I->ID] - OldScores[I->ID]); | |
666 | } | |
667 | } | |
668 | ||
669 | /* Protected things are pushed really high up. This number should put them | |
670 | ahead of everything */ | |
f7f0d6c7 | 671 | for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I) |
d2685fd6 | 672 | { |
6c139d6e | 673 | if ((Flags[I->ID] & Protected) != 0) |
8b4894fe | 674 | Scores[I->ID] += AddProtected; |
c5200869 JAK |
675 | if ((I->Flags & pkgCache::Flag::Essential) == pkgCache::Flag::Essential || |
676 | (I->Flags & pkgCache::Flag::Important) == pkgCache::Flag::Important) | |
8b4894fe MV |
677 | Scores[I->ID] += AddEssential; |
678 | } | |
6c139d6e AL |
679 | } |
680 | /*}}}*/ | |
681 | // ProblemResolver::DoUpgrade - Attempt to upgrade this package /*{{{*/ | |
682 | // --------------------------------------------------------------------- | |
683 | /* This goes through and tries to reinstall packages to make this package | |
684 | installable */ | |
685 | bool pkgProblemResolver::DoUpgrade(pkgCache::PkgIterator Pkg) | |
686 | { | |
74a05226 MV |
687 | pkgDepCache::ActionGroup group(Cache); |
688 | ||
6c139d6e AL |
689 | if ((Flags[Pkg->ID] & Upgradable) == 0 || Cache[Pkg].Upgradable() == false) |
690 | return false; | |
3a486305 AL |
691 | if ((Flags[Pkg->ID] & Protected) == Protected) |
692 | return false; | |
0a8e3465 | 693 | |
6c139d6e AL |
694 | Flags[Pkg->ID] &= ~Upgradable; |
695 | ||
696 | bool WasKept = Cache[Pkg].Keep(); | |
74a05226 | 697 | Cache.MarkInstall(Pkg, false, 0, false); |
6c139d6e | 698 | |
0a8e3465 AL |
699 | // This must be a virtual package or something like that. |
700 | if (Cache[Pkg].InstVerIter(Cache).end() == true) | |
701 | return false; | |
702 | ||
6c139d6e AL |
703 | // Isolate the problem dependency |
704 | bool Fail = false; | |
705 | for (pkgCache::DepIterator D = Cache[Pkg].InstVerIter(Cache).DependsList(); D.end() == false;) | |
706 | { | |
707 | // Compute a single dependency element (glob or) | |
708 | pkgCache::DepIterator Start = D; | |
709 | pkgCache::DepIterator End = D; | |
4b1b89c5 | 710 | for (bool LastOR = true; D.end() == false && LastOR == true;) |
6c139d6e | 711 | { |
b518cca6 | 712 | LastOR = (D->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or; |
0284eee4 | 713 | ++D; |
6c139d6e AL |
714 | if (LastOR == true) |
715 | End = D; | |
716 | } | |
717 | ||
718 | // We only worry about critical deps. | |
719 | if (End.IsCritical() != true) | |
720 | continue; | |
4b1b89c5 AL |
721 | |
722 | // Iterate over all the members in the or group | |
723 | while (1) | |
0a8e3465 | 724 | { |
4b1b89c5 AL |
725 | // Dep is ok now |
726 | if ((Cache[End] & pkgDepCache::DepGInstall) == pkgDepCache::DepGInstall) | |
727 | break; | |
728 | ||
729 | // Do not change protected packages | |
730 | PkgIterator P = Start.SmartTargetPkg(); | |
731 | if ((Flags[P->ID] & Protected) == Protected) | |
732 | { | |
733 | if (Debug == true) | |
47f6d1b7 | 734 | clog << " Reinst Failed because of protected " << P.FullName(false) << endl; |
4b1b89c5 | 735 | Fail = true; |
4b1b89c5 | 736 | } |
648e3cb4 | 737 | else |
6c139d6e | 738 | { |
648e3cb4 AL |
739 | // Upgrade the package if the candidate version will fix the problem. |
740 | if ((Cache[Start] & pkgDepCache::DepCVer) == pkgDepCache::DepCVer) | |
741 | { | |
742 | if (DoUpgrade(P) == false) | |
743 | { | |
744 | if (Debug == true) | |
47f6d1b7 | 745 | clog << " Reinst Failed because of " << P.FullName(false) << endl; |
648e3cb4 AL |
746 | Fail = true; |
747 | } | |
748 | else | |
749 | { | |
750 | Fail = false; | |
751 | break; | |
752 | } | |
753 | } | |
754 | else | |
4b1b89c5 | 755 | { |
648e3cb4 AL |
756 | /* We let the algorithm deal with conflicts on its next iteration, |
757 | it is much smarter than us */ | |
359e46db | 758 | if (Start.IsNegative() == true) |
b2e465d6 | 759 | break; |
648e3cb4 | 760 | |
4b1b89c5 | 761 | if (Debug == true) |
47f6d1b7 | 762 | clog << " Reinst Failed early because of " << Start.TargetPkg().FullName(false) << endl; |
4b1b89c5 | 763 | Fail = true; |
648e3cb4 | 764 | } |
4b1b89c5 | 765 | } |
6c139d6e | 766 | |
4b1b89c5 AL |
767 | if (Start == End) |
768 | break; | |
f7f0d6c7 | 769 | ++Start; |
4b1b89c5 AL |
770 | } |
771 | if (Fail == true) | |
6c139d6e | 772 | break; |
6c139d6e AL |
773 | } |
774 | ||
775 | // Undo our operations - it might be smart to undo everything this did.. | |
776 | if (Fail == true) | |
777 | { | |
778 | if (WasKept == true) | |
74a05226 | 779 | Cache.MarkKeep(Pkg, false, false); |
6c139d6e | 780 | else |
b83cad32 | 781 | Cache.MarkDelete(Pkg, false, 0, false); |
6c139d6e AL |
782 | return false; |
783 | } | |
784 | ||
785 | if (Debug == true) | |
47f6d1b7 | 786 | clog << " Re-Instated " << Pkg.FullName(false) << endl; |
6c139d6e AL |
787 | return true; |
788 | } | |
789 | /*}}}*/ | |
6d38011b DK |
790 | // ProblemResolver::Resolve - calls a resolver to fix the situation /*{{{*/ |
791 | // --------------------------------------------------------------------- | |
792 | /* */ | |
793 | bool pkgProblemResolver::Resolve(bool BrokenFix) | |
794 | { | |
98278a81 | 795 | std::string const solver = _config->Find("APT::Solver", "internal"); |
b57c0e35 DK |
796 | if (solver != "internal") { |
797 | OpTextProgress Prog(*_config); | |
798 | return EDSP::ResolveExternal(solver.c_str(), Cache, false, false, false, &Prog); | |
799 | } | |
6d38011b DK |
800 | return ResolveInternal(BrokenFix); |
801 | } | |
802 | /*}}}*/ | |
803 | // ProblemResolver::ResolveInternal - Run the resolution pass /*{{{*/ | |
6c139d6e AL |
804 | // --------------------------------------------------------------------- |
805 | /* This routines works by calculating a score for each package. The score | |
806 | is derived by considering the package's priority and all reverse | |
807 | dependents giving an integer that reflects the amount of breakage that | |
808 | adjusting the package will inflict. | |
809 | ||
810 | It goes from highest score to lowest and corrects all of the breaks by | |
811 | keeping or removing the dependant packages. If that fails then it removes | |
812 | the package itself and goes on. The routine should be able to intelligently | |
813 | go from any broken state to a fixed state. | |
814 | ||
815 | The BrokenFix flag enables a mode where the algorithm tries to | |
816 | upgrade packages to advoid problems. */ | |
6d38011b | 817 | bool pkgProblemResolver::ResolveInternal(bool const BrokenFix) |
6c139d6e | 818 | { |
74a05226 MV |
819 | pkgDepCache::ActionGroup group(Cache); |
820 | ||
6c139d6e AL |
821 | // Record which packages are marked for install |
822 | bool Again = false; | |
823 | do | |
824 | { | |
825 | Again = false; | |
f7f0d6c7 | 826 | for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I) |
6c139d6e AL |
827 | { |
828 | if (Cache[I].Install() == true) | |
829 | Flags[I->ID] |= PreInstalled; | |
830 | else | |
831 | { | |
832 | if (Cache[I].InstBroken() == true && BrokenFix == true) | |
833 | { | |
74a05226 | 834 | Cache.MarkInstall(I, false, 0, false); |
6c139d6e AL |
835 | if (Cache[I].Install() == true) |
836 | Again = true; | |
837 | } | |
838 | ||
839 | Flags[I->ID] &= ~PreInstalled; | |
840 | } | |
841 | Flags[I->ID] |= Upgradable; | |
842 | } | |
843 | } | |
844 | while (Again == true); | |
845 | ||
32b5dd08 | 846 | if (Debug == true) { |
49b49018 MV |
847 | clog << "Starting pkgProblemResolver with broken count: " |
848 | << Cache.BrokenCount() << endl; | |
32b5dd08 | 849 | } |
6c139d6e AL |
850 | |
851 | MakeScores(); | |
6d38011b DK |
852 | |
853 | unsigned long const Size = Cache.Head().PackageCount; | |
854 | ||
6c139d6e AL |
855 | /* We have to order the packages so that the broken fixing pass |
856 | operates from highest score to lowest. This prevents problems when | |
857 | high score packages cause the removal of lower score packages that | |
858 | would cause the removal of even lower score packages. */ | |
b2e465d6 | 859 | SPtrArray<pkgCache::Package *> PList = new pkgCache::Package *[Size]; |
6c139d6e | 860 | pkgCache::Package **PEnd = PList; |
f7f0d6c7 | 861 | for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I) |
6c139d6e AL |
862 | *PEnd++ = I; |
863 | This = this; | |
864 | qsort(PList,PEnd - PList,sizeof(*PList),&ScoreSort); | |
8b4894fe MV |
865 | |
866 | if (_config->FindB("Debug::pkgProblemResolver::ShowScores",false) == true) | |
867 | { | |
868 | clog << "Show Scores" << endl; | |
869 | for (pkgCache::Package **K = PList; K != PEnd; K++) | |
870 | if (Scores[(*K)->ID] != 0) | |
871 | { | |
872 | pkgCache::PkgIterator Pkg(Cache,*K); | |
873 | clog << Scores[(*K)->ID] << ' ' << Pkg << std::endl; | |
874 | } | |
875 | } | |
6c139d6e | 876 | |
32b5dd08 | 877 | if (Debug == true) { |
49b49018 MV |
878 | clog << "Starting 2 pkgProblemResolver with broken count: " |
879 | << Cache.BrokenCount() << endl; | |
32b5dd08 | 880 | } |
8b4894fe | 881 | |
6c139d6e AL |
882 | /* Now consider all broken packages. For each broken package we either |
883 | remove the package or fix it's problem. We do this once, it should | |
884 | not be possible for a loop to form (that is a < b < c and fixing b by | |
885 | changing a breaks c) */ | |
886 | bool Change = true; | |
09a10f9c | 887 | bool const TryFixByInstall = _config->FindB("pkgProblemResolver::FixByInstall", true); |
6c139d6e AL |
888 | for (int Counter = 0; Counter != 10 && Change == true; Counter++) |
889 | { | |
890 | Change = false; | |
891 | for (pkgCache::Package **K = PList; K != PEnd; K++) | |
892 | { | |
893 | pkgCache::PkgIterator I(Cache,*K); | |
894 | ||
895 | /* We attempt to install this and see if any breaks result, | |
896 | this takes care of some strange cases */ | |
897 | if (Cache[I].CandidateVer != Cache[I].InstallVer && | |
898 | I->CurrentVer != 0 && Cache[I].InstallVer != 0 && | |
899 | (Flags[I->ID] & PreInstalled) != 0 && | |
0a8e3465 AL |
900 | (Flags[I->ID] & Protected) == 0 && |
901 | (Flags[I->ID] & ReInstateTried) == 0) | |
6c139d6e AL |
902 | { |
903 | if (Debug == true) | |
09a10f9c | 904 | clog << " Try to Re-Instate (" << Counter << ") " << I.FullName(false) << endl; |
a6568219 | 905 | unsigned long OldBreaks = Cache.BrokenCount(); |
6c139d6e | 906 | pkgCache::Version *OldVer = Cache[I].InstallVer; |
0a8e3465 AL |
907 | Flags[I->ID] &= ReInstateTried; |
908 | ||
74a05226 | 909 | Cache.MarkInstall(I, false, 0, false); |
6c139d6e AL |
910 | if (Cache[I].InstBroken() == true || |
911 | OldBreaks < Cache.BrokenCount()) | |
912 | { | |
913 | if (OldVer == 0) | |
b83cad32 | 914 | Cache.MarkDelete(I, false, 0, false); |
6c139d6e | 915 | else |
74a05226 | 916 | Cache.MarkKeep(I, false, false); |
6c139d6e AL |
917 | } |
918 | else | |
919 | if (Debug == true) | |
47f6d1b7 | 920 | clog << "Re-Instated " << I.FullName(false) << " (" << OldBreaks << " vs " << Cache.BrokenCount() << ')' << endl; |
6c139d6e AL |
921 | } |
922 | ||
923 | if (Cache[I].InstallVer == 0 || Cache[I].InstBroken() == false) | |
924 | continue; | |
925 | ||
00b47c98 | 926 | if (Debug == true) |
09a10f9c | 927 | clog << "Investigating (" << Counter << ") " << I << endl; |
00b47c98 | 928 | |
6c139d6e AL |
929 | // Isolate the problem dependency |
930 | PackageKill KillList[100]; | |
931 | PackageKill *LEnd = KillList; | |
421c8d10 AL |
932 | bool InOr = false; |
933 | pkgCache::DepIterator Start; | |
934 | pkgCache::DepIterator End; | |
b2e465d6 | 935 | PackageKill *OldEnd = LEnd; |
648e3cb4 AL |
936 | |
937 | enum {OrRemove,OrKeep} OrOp = OrRemove; | |
421c8d10 AL |
938 | for (pkgCache::DepIterator D = Cache[I].InstVerIter(Cache).DependsList(); |
939 | D.end() == false || InOr == true;) | |
6c139d6e AL |
940 | { |
941 | // Compute a single dependency element (glob or) | |
648e3cb4 AL |
942 | if (Start == End) |
943 | { | |
944 | // Decide what to do | |
09a10f9c | 945 | if (InOr == true && OldEnd == LEnd) |
648e3cb4 | 946 | { |
09a10f9c | 947 | if (OrOp == OrRemove) |
70777d4b AL |
948 | { |
949 | if ((Flags[I->ID] & Protected) != Protected) | |
00b47c98 AL |
950 | { |
951 | if (Debug == true) | |
47f6d1b7 | 952 | clog << " Or group remove for " << I.FullName(false) << endl; |
b83cad32 | 953 | Cache.MarkDelete(I, false, 0, false); |
cd14eaf2 | 954 | Change = true; |
09a10f9c DK |
955 | } |
956 | } | |
957 | else if (OrOp == OrKeep) | |
00b47c98 AL |
958 | { |
959 | if (Debug == true) | |
47f6d1b7 | 960 | clog << " Or group keep for " << I.FullName(false) << endl; |
74a05226 | 961 | Cache.MarkKeep(I, false, false); |
cd14eaf2 | 962 | Change = true; |
b2e465d6 | 963 | } |
648e3cb4 AL |
964 | } |
965 | ||
b2e465d6 AL |
966 | /* We do an extra loop (as above) to finalize the or group |
967 | processing */ | |
968 | InOr = false; | |
648e3cb4 | 969 | OrOp = OrRemove; |
421c8d10 | 970 | D.GlobOr(Start,End); |
b2e465d6 AL |
971 | if (Start.end() == true) |
972 | break; | |
cd14eaf2 | 973 | |
b2e465d6 AL |
974 | // We only worry about critical deps. |
975 | if (End.IsCritical() != true) | |
976 | continue; | |
cd14eaf2 | 977 | |
648e3cb4 AL |
978 | InOr = Start != End; |
979 | OldEnd = LEnd; | |
cd14eaf2 | 980 | } |
421c8d10 | 981 | else |
4cc152f9 | 982 | { |
f7f0d6c7 | 983 | ++Start; |
4cc152f9 MV |
984 | // We only worry about critical deps. |
985 | if (Start.IsCritical() != true) | |
986 | continue; | |
987 | } | |
cd14eaf2 | 988 | |
6c139d6e AL |
989 | // Dep is ok |
990 | if ((Cache[End] & pkgDepCache::DepGInstall) == pkgDepCache::DepGInstall) | |
cd14eaf2 AL |
991 | { |
992 | InOr = false; | |
6c139d6e | 993 | continue; |
cd14eaf2 AL |
994 | } |
995 | ||
6c139d6e | 996 | if (Debug == true) |
47f6d1b7 | 997 | clog << "Broken " << Start << endl; |
fcf85120 AL |
998 | |
999 | /* Look across the version list. If there are no possible | |
1000 | targets then we keep the package and bail. This is necessary | |
1001 | if a package has a dep on another package that cant be found */ | |
b2e465d6 | 1002 | SPtrArray<pkgCache::Version *> VList = Start.AllTargets(); |
fcf85120 | 1003 | if (*VList == 0 && (Flags[I->ID] & Protected) != Protected && |
359e46db | 1004 | Start.IsNegative() == false && |
fcf85120 | 1005 | Cache[I].NowBroken() == false) |
648e3cb4 AL |
1006 | { |
1007 | if (InOr == true) | |
1008 | { | |
1009 | /* No keep choice because the keep being OK could be the | |
1010 | result of another element in the OR group! */ | |
1011 | continue; | |
1012 | } | |
1013 | ||
fcf85120 | 1014 | Change = true; |
74a05226 | 1015 | Cache.MarkKeep(I, false, false); |
fcf85120 AL |
1016 | break; |
1017 | } | |
1018 | ||
6c139d6e AL |
1019 | bool Done = false; |
1020 | for (pkgCache::Version **V = VList; *V != 0; V++) | |
1021 | { | |
1022 | pkgCache::VerIterator Ver(Cache,*V); | |
1023 | pkgCache::PkgIterator Pkg = Ver.ParentPkg(); | |
a6bfe583 | 1024 | |
2ba99db8 MV |
1025 | /* This is a conflicts, and the version we are looking |
1026 | at is not the currently selected version of the | |
1027 | package, which means it is not necessary to | |
1028 | remove/keep */ | |
359e46db | 1029 | if (Cache[Pkg].InstallVer != Ver && Start.IsNegative() == true) |
4429616b | 1030 | { |
2ba99db8 MV |
1031 | if (Debug) |
1032 | clog << " Conflicts//Breaks against version " | |
1033 | << Ver.VerStr() << " for " << Pkg.Name() | |
1034 | << " but that is not InstVer, ignoring" | |
24e93662 | 1035 | << endl; |
2ba99db8 | 1036 | continue; |
4429616b MV |
1037 | } |
1038 | ||
6c139d6e | 1039 | if (Debug == true) |
47f6d1b7 DK |
1040 | clog << " Considering " << Pkg.FullName(false) << ' ' << (int)Scores[Pkg->ID] << |
1041 | " as a solution to " << I.FullName(false) << ' ' << (int)Scores[I->ID] << endl; | |
a6bfe583 AL |
1042 | |
1043 | /* Try to fix the package under consideration rather than | |
1044 | fiddle with the VList package */ | |
6c139d6e | 1045 | if (Scores[I->ID] <= Scores[Pkg->ID] || |
421c8d10 | 1046 | ((Cache[Start] & pkgDepCache::DepNow) == 0 && |
359e46db | 1047 | End.IsNegative() == false)) |
6c139d6e | 1048 | { |
200f8c52 | 1049 | // Try a little harder to fix protected packages.. |
3b5421b4 | 1050 | if ((Flags[I->ID] & Protected) == Protected) |
200f8c52 AL |
1051 | { |
1052 | if (DoUpgrade(Pkg) == true) | |
0296c633 | 1053 | { |
b2e465d6 AL |
1054 | if (Scores[Pkg->ID] > Scores[I->ID]) |
1055 | Scores[Pkg->ID] = Scores[I->ID]; | |
0296c633 AL |
1056 | break; |
1057 | } | |
1058 | ||
6c139d6e | 1059 | continue; |
200f8c52 AL |
1060 | } |
1061 | ||
1062 | /* See if a keep will do, unless the package is protected, | |
648e3cb4 AL |
1063 | then installing it will be necessary */ |
1064 | bool Installed = Cache[I].Install(); | |
74a05226 | 1065 | Cache.MarkKeep(I, false, false); |
6c139d6e AL |
1066 | if (Cache[I].InstBroken() == false) |
1067 | { | |
648e3cb4 AL |
1068 | // Unwind operation will be keep now |
1069 | if (OrOp == OrRemove) | |
1070 | OrOp = OrKeep; | |
1071 | ||
1072 | // Restore | |
1073 | if (InOr == true && Installed == true) | |
74a05226 | 1074 | Cache.MarkInstall(I, false, 0, false); |
648e3cb4 | 1075 | |
6c139d6e | 1076 | if (Debug == true) |
47f6d1b7 | 1077 | clog << " Holding Back " << I.FullName(false) << " rather than change " << Start.TargetPkg().FullName(false) << endl; |
6c139d6e AL |
1078 | } |
1079 | else | |
421c8d10 | 1080 | { |
6c139d6e AL |
1081 | if (BrokenFix == false || DoUpgrade(I) == false) |
1082 | { | |
421c8d10 | 1083 | // Consider other options |
87da7451 | 1084 | if (InOr == false || Cache[I].Garbage == true) |
421c8d10 | 1085 | { |
6910a2ac | 1086 | if (Debug == true) |
47f6d1b7 | 1087 | clog << " Removing " << I.FullName(false) << " rather than change " << Start.TargetPkg().FullName(false) << endl; |
b83cad32 | 1088 | Cache.MarkDelete(I, false, 0, false); |
6910a2ac DK |
1089 | if (Counter > 1 && Scores[Pkg->ID] > Scores[I->ID]) |
1090 | Scores[I->ID] = Scores[Pkg->ID]; | |
d6ebeb21 | 1091 | } |
09a10f9c DK |
1092 | else if (TryFixByInstall == true && |
1093 | Start.TargetPkg()->CurrentVer == 0 && | |
1094 | Cache[Start.TargetPkg()].Delete() == false && | |
a3f1a6cc | 1095 | (Flags[Start.TargetPkg()->ID] & ToRemove) != ToRemove && |
09a10f9c DK |
1096 | Cache.GetCandidateVer(Start.TargetPkg()).end() == false) |
1097 | { | |
1098 | /* Before removing or keeping the package with the broken dependency | |
1099 | try instead to install the first not previously installed package | |
1100 | solving this dependency. This helps every time a previous solver | |
1101 | is removed by the resolver because of a conflict or alike but it is | |
1102 | dangerous as it could trigger new breaks/conflicts… */ | |
443266ef DK |
1103 | if (Debug == true) |
1104 | clog << " Try Installing " << Start.TargetPkg() << " before changing " << I.FullName(false) << std::endl; | |
09a10f9c DK |
1105 | unsigned long const OldBroken = Cache.BrokenCount(); |
1106 | Cache.MarkInstall(Start.TargetPkg(), true, 1, false); | |
1107 | // FIXME: we should undo the complete MarkInstall process here | |
1108 | if (Cache[Start.TargetPkg()].InstBroken() == true || Cache.BrokenCount() > OldBroken) | |
1109 | Cache.MarkDelete(Start.TargetPkg(), false, 1, false); | |
1110 | } | |
0a8e3465 | 1111 | } |
6c139d6e | 1112 | } |
b5dc9785 | 1113 | |
6c139d6e AL |
1114 | Change = true; |
1115 | Done = true; | |
1116 | break; | |
1117 | } | |
1118 | else | |
1119 | { | |
308c7d30 IJ |
1120 | if (Start->Type == pkgCache::Dep::DpkgBreaks) |
1121 | { | |
76264cb7 MV |
1122 | // first, try upgradring the package, if that |
1123 | // does not help, the breaks goes onto the | |
1124 | // kill list | |
2ba99db8 | 1125 | // |
76264cb7 | 1126 | // FIXME: use DoUpgrade(Pkg) instead? |
2ba99db8 | 1127 | if (Cache[End] & pkgDepCache::DepGCVer) |
76264cb7 | 1128 | { |
308c7d30 | 1129 | if (Debug) |
47f6d1b7 | 1130 | clog << " Upgrading " << Pkg.FullName(false) << " due to Breaks field in " << I.FullName(false) << endl; |
308c7d30 IJ |
1131 | Cache.MarkInstall(Pkg, false, 0, false); |
1132 | continue; | |
1133 | } | |
308c7d30 IJ |
1134 | } |
1135 | ||
648e3cb4 | 1136 | // Skip adding to the kill list if it is protected |
6c139d6e AL |
1137 | if ((Flags[Pkg->ID] & Protected) != 0) |
1138 | continue; | |
a6bfe583 AL |
1139 | |
1140 | if (Debug == true) | |
47f6d1b7 | 1141 | clog << " Added " << Pkg.FullName(false) << " to the remove list" << endl; |
6c139d6e AL |
1142 | |
1143 | LEnd->Pkg = Pkg; | |
1144 | LEnd->Dep = End; | |
1145 | LEnd++; | |
0a8e3465 | 1146 | |
b47053bd | 1147 | if (Start.IsNegative() == false) |
6c139d6e AL |
1148 | break; |
1149 | } | |
1150 | } | |
1151 | ||
1152 | // Hm, nothing can possibly satisify this dep. Nuke it. | |
359e46db DK |
1153 | if (VList[0] == 0 && |
1154 | Start.IsNegative() == false && | |
648e3cb4 | 1155 | (Flags[I->ID] & Protected) != Protected) |
6c139d6e | 1156 | { |
648e3cb4 | 1157 | bool Installed = Cache[I].Install(); |
6c139d6e AL |
1158 | Cache.MarkKeep(I); |
1159 | if (Cache[I].InstBroken() == false) | |
1160 | { | |
648e3cb4 AL |
1161 | // Unwind operation will be keep now |
1162 | if (OrOp == OrRemove) | |
1163 | OrOp = OrKeep; | |
1164 | ||
1165 | // Restore | |
1166 | if (InOr == true && Installed == true) | |
74a05226 | 1167 | Cache.MarkInstall(I, false, 0, false); |
648e3cb4 | 1168 | |
6c139d6e | 1169 | if (Debug == true) |
47f6d1b7 | 1170 | clog << " Holding Back " << I.FullName(false) << " because I can't find " << Start.TargetPkg().FullName(false) << endl; |
6c139d6e AL |
1171 | } |
1172 | else | |
1173 | { | |
1174 | if (Debug == true) | |
47f6d1b7 | 1175 | clog << " Removing " << I.FullName(false) << " because I can't find " << Start.TargetPkg().FullName(false) << endl; |
648e3cb4 | 1176 | if (InOr == false) |
b83cad32 | 1177 | Cache.MarkDelete(I, false, 0, false); |
6c139d6e AL |
1178 | } |
1179 | ||
1180 | Change = true; | |
1181 | Done = true; | |
1182 | } | |
1183 | ||
421c8d10 AL |
1184 | // Try some more |
1185 | if (InOr == true) | |
1186 | continue; | |
1187 | ||
6c139d6e AL |
1188 | if (Done == true) |
1189 | break; | |
1190 | } | |
1191 | ||
1192 | // Apply the kill list now | |
1193 | if (Cache[I].InstallVer != 0) | |
648e3cb4 | 1194 | { |
6c139d6e | 1195 | for (PackageKill *J = KillList; J != LEnd; J++) |
6c139d6e | 1196 | { |
648e3cb4 AL |
1197 | Change = true; |
1198 | if ((Cache[J->Dep] & pkgDepCache::DepGNow) == 0) | |
1199 | { | |
359e46db | 1200 | if (J->Dep.IsNegative() == true) |
648e3cb4 AL |
1201 | { |
1202 | if (Debug == true) | |
47f6d1b7 | 1203 | clog << " Fixing " << I.FullName(false) << " via remove of " << J->Pkg.FullName(false) << endl; |
b83cad32 | 1204 | Cache.MarkDelete(J->Pkg, false, 0, false); |
648e3cb4 AL |
1205 | } |
1206 | } | |
1207 | else | |
6c139d6e AL |
1208 | { |
1209 | if (Debug == true) | |
47f6d1b7 | 1210 | clog << " Fixing " << I.FullName(false) << " via keep of " << J->Pkg.FullName(false) << endl; |
74a05226 | 1211 | Cache.MarkKeep(J->Pkg, false, false); |
6c139d6e | 1212 | } |
b2e465d6 | 1213 | |
648e3cb4 | 1214 | if (Counter > 1) |
b2e465d6 AL |
1215 | { |
1216 | if (Scores[I->ID] > Scores[J->Pkg->ID]) | |
1217 | Scores[J->Pkg->ID] = Scores[I->ID]; | |
1218 | } | |
648e3cb4 AL |
1219 | } |
1220 | } | |
1221 | } | |
6c139d6e AL |
1222 | } |
1223 | ||
1224 | if (Debug == true) | |
0a8e3465 | 1225 | clog << "Done" << endl; |
b2e465d6 | 1226 | |
6c139d6e | 1227 | if (Cache.BrokenCount() != 0) |
b5dc9785 AL |
1228 | { |
1229 | // See if this is the result of a hold | |
1230 | pkgCache::PkgIterator I = Cache.PkgBegin(); | |
f7f0d6c7 | 1231 | for (;I.end() != true; ++I) |
b5dc9785 AL |
1232 | { |
1233 | if (Cache[I].InstBroken() == false) | |
1234 | continue; | |
1235 | if ((Flags[I->ID] & Protected) != Protected) | |
b2e465d6 | 1236 | return _error->Error(_("Error, pkgProblemResolver::Resolve generated breaks, this may be caused by held packages.")); |
b5dc9785 | 1237 | } |
b2e465d6 | 1238 | return _error->Error(_("Unable to correct problems, you have held broken packages.")); |
b5dc9785 AL |
1239 | } |
1240 | ||
fce72602 | 1241 | // set the auto-flags (mvo: I'm not sure if we _really_ need this) |
80fa0d8a | 1242 | pkgCache::PkgIterator I = Cache.PkgBegin(); |
f7f0d6c7 | 1243 | for (;I.end() != true; ++I) { |
80fa0d8a | 1244 | if (Cache[I].NewInstall() && !(Flags[I->ID] & PreInstalled)) { |
120365ce | 1245 | if(_config->FindI("Debug::pkgAutoRemove",false)) { |
47f6d1b7 | 1246 | std::clog << "Resolve installed new pkg: " << I.FullName(false) |
120365ce MV |
1247 | << " (now marking it as auto)" << std::endl; |
1248 | } | |
80fa0d8a MV |
1249 | Cache[I].Flags |= pkgCache::Flag::Auto; |
1250 | } | |
1251 | } | |
1252 | ||
1253 | ||
0a8e3465 AL |
1254 | return true; |
1255 | } | |
1256 | /*}}}*/ | |
953b348c MV |
1257 | // ProblemResolver::BreaksInstOrPolicy - Check if the given pkg is broken/*{{{*/ |
1258 | // --------------------------------------------------------------------- | |
1259 | /* This checks if the given package is broken either by a hard dependency | |
1260 | (InstBroken()) or by introducing a new policy breakage e.g. new | |
1261 | unsatisfied recommends for a package that was in "policy-good" state | |
1262 | ||
1263 | Note that this is not perfect as it will ignore further breakage | |
1264 | for already broken policy (recommends) | |
1265 | */ | |
1266 | bool pkgProblemResolver::InstOrNewPolicyBroken(pkgCache::PkgIterator I) | |
1267 | { | |
953b348c MV |
1268 | // a broken install is always a problem |
1269 | if (Cache[I].InstBroken() == true) | |
deec6474 DK |
1270 | { |
1271 | if (Debug == true) | |
1272 | std::clog << " Dependencies are not satisfied for " << I << std::endl; | |
953b348c | 1273 | return true; |
deec6474 | 1274 | } |
953b348c MV |
1275 | |
1276 | // a newly broken policy (recommends/suggests) is a problem | |
1277 | if (Cache[I].NowPolicyBroken() == false && | |
1278 | Cache[I].InstPolicyBroken() == true) | |
deec6474 DK |
1279 | { |
1280 | if (Debug == true) | |
1281 | std::clog << " Policy breaks with upgrade of " << I << std::endl; | |
953b348c | 1282 | return true; |
deec6474 DK |
1283 | } |
1284 | ||
953b348c MV |
1285 | return false; |
1286 | } | |
36a171e1 | 1287 | /*}}}*/ |
0a8e3465 AL |
1288 | // ProblemResolver::ResolveByKeep - Resolve problems using keep /*{{{*/ |
1289 | // --------------------------------------------------------------------- | |
1290 | /* This is the work horse of the soft upgrade routine. It is very gental | |
1291 | in that it does not install or remove any packages. It is assumed that the | |
1292 | system was non-broken previously. */ | |
1293 | bool pkgProblemResolver::ResolveByKeep() | |
741b7da9 | 1294 | { |
98278a81 | 1295 | std::string const solver = _config->Find("APT::Solver", "internal"); |
b57c0e35 DK |
1296 | if (solver != "internal") { |
1297 | OpTextProgress Prog(*_config); | |
1298 | return EDSP::ResolveExternal(solver.c_str(), Cache, true, false, false, &Prog); | |
1299 | } | |
741b7da9 DK |
1300 | return ResolveByKeepInternal(); |
1301 | } | |
1302 | /*}}}*/ | |
1303 | // ProblemResolver::ResolveByKeepInternal - Resolve problems using keep /*{{{*/ | |
1304 | // --------------------------------------------------------------------- | |
1305 | /* This is the work horse of the soft upgrade routine. It is very gental | |
1306 | in that it does not install or remove any packages. It is assumed that the | |
1307 | system was non-broken previously. */ | |
1308 | bool pkgProblemResolver::ResolveByKeepInternal() | |
0a8e3465 | 1309 | { |
74a05226 MV |
1310 | pkgDepCache::ActionGroup group(Cache); |
1311 | ||
b2e465d6 | 1312 | unsigned long Size = Cache.Head().PackageCount; |
0a8e3465 | 1313 | |
0a8e3465 AL |
1314 | MakeScores(); |
1315 | ||
1316 | /* We have to order the packages so that the broken fixing pass | |
1317 | operates from highest score to lowest. This prevents problems when | |
1318 | high score packages cause the removal of lower score packages that | |
1319 | would cause the removal of even lower score packages. */ | |
1320 | pkgCache::Package **PList = new pkgCache::Package *[Size]; | |
1321 | pkgCache::Package **PEnd = PList; | |
f7f0d6c7 | 1322 | for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I) |
0a8e3465 AL |
1323 | *PEnd++ = I; |
1324 | This = this; | |
1325 | qsort(PList,PEnd - PList,sizeof(*PList),&ScoreSort); | |
8b4894fe MV |
1326 | |
1327 | if (_config->FindB("Debug::pkgProblemResolver::ShowScores",false) == true) | |
1328 | { | |
1329 | clog << "Show Scores" << endl; | |
1330 | for (pkgCache::Package **K = PList; K != PEnd; K++) | |
1331 | if (Scores[(*K)->ID] != 0) | |
1332 | { | |
1333 | pkgCache::PkgIterator Pkg(Cache,*K); | |
1334 | clog << Scores[(*K)->ID] << ' ' << Pkg << std::endl; | |
1335 | } | |
1336 | } | |
1337 | ||
1338 | if (Debug == true) | |
1339 | clog << "Entering ResolveByKeep" << endl; | |
1340 | ||
0a8e3465 AL |
1341 | // Consider each broken package |
1342 | pkgCache::Package **LastStop = 0; | |
1343 | for (pkgCache::Package **K = PList; K != PEnd; K++) | |
1344 | { | |
1345 | pkgCache::PkgIterator I(Cache,*K); | |
1346 | ||
953b348c | 1347 | if (Cache[I].InstallVer == 0) |
0a8e3465 AL |
1348 | continue; |
1349 | ||
953b348c MV |
1350 | if (InstOrNewPolicyBroken(I) == false) |
1351 | continue; | |
1352 | ||
0a8e3465 | 1353 | /* Keep the package. If this works then great, otherwise we have |
b2e465d6 | 1354 | to be significantly more agressive and manipulate its dependencies */ |
0a8e3465 AL |
1355 | if ((Flags[I->ID] & Protected) == 0) |
1356 | { | |
1357 | if (Debug == true) | |
47f6d1b7 | 1358 | clog << "Keeping package " << I.FullName(false) << endl; |
74a05226 | 1359 | Cache.MarkKeep(I, false, false); |
953b348c | 1360 | if (InstOrNewPolicyBroken(I) == false) |
0a8e3465 | 1361 | { |
b2e465d6 | 1362 | K = PList - 1; |
0a8e3465 AL |
1363 | continue; |
1364 | } | |
1365 | } | |
1366 | ||
1367 | // Isolate the problem dependencies | |
1368 | for (pkgCache::DepIterator D = Cache[I].InstVerIter(Cache).DependsList(); D.end() == false;) | |
1369 | { | |
c5532863 AL |
1370 | DepIterator Start; |
1371 | DepIterator End; | |
1372 | D.GlobOr(Start,End); | |
1373 | ||
0a8e3465 AL |
1374 | // We only worry about critical deps. |
1375 | if (End.IsCritical() != true) | |
1376 | continue; | |
1377 | ||
1378 | // Dep is ok | |
1379 | if ((Cache[End] & pkgDepCache::DepGInstall) == pkgDepCache::DepGInstall) | |
1380 | continue; | |
c5532863 AL |
1381 | |
1382 | /* Hm, the group is broken.. I suppose the best thing to do is to | |
1383 | is to try every combination of keep/not-keep for the set, but thats | |
1384 | slow, and this never happens, just be conservative and assume the | |
1385 | list of ors is in preference and keep till it starts to work. */ | |
1386 | while (true) | |
0a8e3465 | 1387 | { |
c5532863 | 1388 | if (Debug == true) |
47f6d1b7 | 1389 | clog << "Package " << I.FullName(false) << " " << Start << endl; |
8b4894fe | 1390 | |
c5532863 AL |
1391 | // Look at all the possible provides on this package |
1392 | SPtrArray<pkgCache::Version *> VList = Start.AllTargets(); | |
1393 | for (pkgCache::Version **V = VList; *V != 0; V++) | |
0a8e3465 | 1394 | { |
c5532863 AL |
1395 | pkgCache::VerIterator Ver(Cache,*V); |
1396 | pkgCache::PkgIterator Pkg = Ver.ParentPkg(); | |
1397 | ||
1398 | // It is not keepable | |
1399 | if (Cache[Pkg].InstallVer == 0 || | |
1400 | Pkg->CurrentVer == 0) | |
1401 | continue; | |
1402 | ||
1403 | if ((Flags[I->ID] & Protected) == 0) | |
1404 | { | |
1405 | if (Debug == true) | |
47f6d1b7 | 1406 | clog << " Keeping Package " << Pkg.FullName(false) << " due to " << Start.DepType() << endl; |
74a05226 | 1407 | Cache.MarkKeep(Pkg, false, false); |
c5532863 AL |
1408 | } |
1409 | ||
953b348c | 1410 | if (InstOrNewPolicyBroken(I) == false) |
c5532863 | 1411 | break; |
0a8e3465 AL |
1412 | } |
1413 | ||
953b348c | 1414 | if (InstOrNewPolicyBroken(I) == false) |
0a8e3465 | 1415 | break; |
0a8e3465 | 1416 | |
c5532863 AL |
1417 | if (Start == End) |
1418 | break; | |
f7f0d6c7 | 1419 | ++Start; |
c5532863 AL |
1420 | } |
1421 | ||
953b348c | 1422 | if (InstOrNewPolicyBroken(I) == false) |
0a8e3465 AL |
1423 | break; |
1424 | } | |
1425 | ||
953b348c | 1426 | if (InstOrNewPolicyBroken(I) == true) |
0a8e3465 AL |
1427 | continue; |
1428 | ||
1429 | // Restart again. | |
0291f645 JT |
1430 | if (K == LastStop) { |
1431 | // I is an iterator based off our temporary package list, | |
1432 | // so copy the name we need before deleting the temporary list | |
1433 | std::string const LoopingPackage = I.FullName(false); | |
1434 | delete[] PList; | |
1435 | return _error->Error("Internal Error, pkgProblemResolver::ResolveByKeep is looping on package %s.", LoopingPackage.c_str()); | |
1436 | } | |
0a8e3465 | 1437 | LastStop = K; |
b2e465d6 | 1438 | K = PList - 1; |
0291f645 | 1439 | } |
6c139d6e | 1440 | |
0291f645 | 1441 | delete[] PList; |
6c139d6e AL |
1442 | return true; |
1443 | } | |
1444 | /*}}}*/ | |
f3c736f9 | 1445 | // ProblemResolver::InstallProtect - deprecated cpu-eating no-op /*{{{*/ |
3b5421b4 | 1446 | // --------------------------------------------------------------------- |
f3c736f9 DK |
1447 | /* Actions issued with FromUser bit set are protected from further |
1448 | modification (expect by other calls with FromUser set) nowadays , so we | |
1449 | don't need to reissue actions here, they are already set in stone. */ | |
3b5421b4 AL |
1450 | void pkgProblemResolver::InstallProtect() |
1451 | { | |
74a05226 MV |
1452 | pkgDepCache::ActionGroup group(Cache); |
1453 | ||
f7f0d6c7 | 1454 | for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I) |
3b5421b4 AL |
1455 | { |
1456 | if ((Flags[I->ID] & Protected) == Protected) | |
1457 | { | |
1458 | if ((Flags[I->ID] & ToRemove) == ToRemove) | |
1459 | Cache.MarkDelete(I); | |
c15f5690 MV |
1460 | else |
1461 | { | |
da543ed8 OS |
1462 | // preserve the information whether the package was auto |
1463 | // or manually installed | |
c15f5690 MV |
1464 | bool autoInst = (Cache[I].Flags & pkgCache::Flag::Auto); |
1465 | Cache.MarkInstall(I, false, 0, !autoInst); | |
1466 | } | |
3b5421b4 AL |
1467 | } |
1468 | } | |
1469 | } | |
1470 | /*}}}*/ | |
b2e465d6 AL |
1471 | // PrioSortList - Sort a list of versions by priority /*{{{*/ |
1472 | // --------------------------------------------------------------------- | |
1473 | /* This is ment to be used in conjunction with AllTargets to get a list | |
1474 | of versions ordered by preference. */ | |
1475 | static pkgCache *PrioCache; | |
1476 | static int PrioComp(const void *A,const void *B) | |
1477 | { | |
1478 | pkgCache::VerIterator L(*PrioCache,*(pkgCache::Version **)A); | |
1479 | pkgCache::VerIterator R(*PrioCache,*(pkgCache::Version **)B); | |
1480 | ||
1481 | if ((L.ParentPkg()->Flags & pkgCache::Flag::Essential) == pkgCache::Flag::Essential && | |
b8c0f9b7 AL |
1482 | (R.ParentPkg()->Flags & pkgCache::Flag::Essential) != pkgCache::Flag::Essential) |
1483 | return 1; | |
b2e465d6 | 1484 | if ((L.ParentPkg()->Flags & pkgCache::Flag::Essential) != pkgCache::Flag::Essential && |
b8c0f9b7 AL |
1485 | (R.ParentPkg()->Flags & pkgCache::Flag::Essential) == pkgCache::Flag::Essential) |
1486 | return -1; | |
c5200869 JAK |
1487 | |
1488 | if ((L.ParentPkg()->Flags & pkgCache::Flag::Important) == pkgCache::Flag::Important && | |
1489 | (R.ParentPkg()->Flags & pkgCache::Flag::Important) != pkgCache::Flag::Important) | |
1490 | return 1; | |
1491 | if ((L.ParentPkg()->Flags & pkgCache::Flag::Important) != pkgCache::Flag::Important && | |
1492 | (R.ParentPkg()->Flags & pkgCache::Flag::Important) == pkgCache::Flag::Important) | |
1493 | return -1; | |
b2e465d6 AL |
1494 | |
1495 | if (L->Priority != R->Priority) | |
b8c0f9b7 | 1496 | return R->Priority - L->Priority; |
b2e465d6 AL |
1497 | return strcmp(L.ParentPkg().Name(),R.ParentPkg().Name()); |
1498 | } | |
1499 | void pkgPrioSortList(pkgCache &Cache,pkgCache::Version **List) | |
1500 | { | |
1501 | unsigned long Count = 0; | |
1502 | PrioCache = &Cache; | |
1503 | for (pkgCache::Version **I = List; *I != 0; I++) | |
1504 | Count++; | |
1505 | qsort(List,Count,sizeof(*List),PrioComp); | |
1506 | } | |
1507 | /*}}}*/ | |
db09a1c5 | 1508 | // ListUpdate - construct Fetcher and update the cache files /*{{{*/ |
760d4968 MV |
1509 | // --------------------------------------------------------------------- |
1510 | /* This is a simple wrapper to update the cache. it will fetch stuff | |
1511 | * from the network (or any other sources defined in sources.list) | |
1512 | */ | |
1513 | bool ListUpdate(pkgAcquireStatus &Stat, | |
1514 | pkgSourceList &List, | |
1515 | int PulseInterval) | |
1516 | { | |
1cd1c398 DK |
1517 | pkgAcquire Fetcher; |
1518 | if (Fetcher.Setup(&Stat, _config->FindDir("Dir::State::Lists")) == false) | |
1519 | return false; | |
760d4968 MV |
1520 | |
1521 | // Populate it with the source selection | |
1522 | if (List.GetIndexes(&Fetcher) == false) | |
1523 | return false; | |
1524 | ||
db09a1c5 DK |
1525 | return AcquireUpdate(Fetcher, PulseInterval, true); |
1526 | } | |
1527 | /*}}}*/ | |
1528 | // AcquireUpdate - take Fetcher and update the cache files /*{{{*/ | |
1529 | // --------------------------------------------------------------------- | |
1530 | /* This is a simple wrapper to update the cache with a provided acquire | |
1531 | * If you only need control over Status and the used SourcesList use | |
1532 | * ListUpdate method instead. | |
1533 | */ | |
1534 | bool AcquireUpdate(pkgAcquire &Fetcher, int const PulseInterval, | |
1535 | bool const RunUpdateScripts, bool const ListCleanup) | |
1536 | { | |
760d4968 | 1537 | // Run scripts |
db09a1c5 DK |
1538 | if (RunUpdateScripts == true) |
1539 | RunScripts("APT::Update::Pre-Invoke"); | |
1540 | ||
1541 | pkgAcquire::RunResult res; | |
1542 | if(PulseInterval > 0) | |
760d4968 MV |
1543 | res = Fetcher.Run(PulseInterval); |
1544 | else | |
1545 | res = Fetcher.Run(); | |
1546 | ||
1547 | if (res == pkgAcquire::Failed) | |
1548 | return false; | |
1549 | ||
1550 | bool Failed = false; | |
1551 | bool TransientNetworkFailure = false; | |
1552 | for (pkgAcquire::ItemIterator I = Fetcher.ItemsBegin(); | |
f7f0d6c7 | 1553 | I != Fetcher.ItemsEnd(); ++I) |
760d4968 MV |
1554 | { |
1555 | if ((*I)->Status == pkgAcquire::Item::StatDone) | |
1556 | continue; | |
1557 | ||
1558 | (*I)->Finished(); | |
1559 | ||
70b3d263 MV |
1560 | ::URI uri((*I)->DescURI()); |
1561 | uri.User.clear(); | |
1562 | uri.Password.clear(); | |
1563 | string descUri = string(uri); | |
4805f1cf | 1564 | _error->Warning(_("Failed to fetch %s %s\n"), descUri.c_str(), |
760d4968 MV |
1565 | (*I)->ErrorText.c_str()); |
1566 | ||
1567 | if ((*I)->Status == pkgAcquire::Item::StatTransientNetworkError) | |
1568 | { | |
1569 | TransientNetworkFailure = true; | |
1570 | continue; | |
1571 | } | |
1572 | ||
1573 | Failed = true; | |
1574 | } | |
1575 | ||
1576 | // Clean out any old list files | |
1577 | // Keep "APT::Get::List-Cleanup" name for compatibility, but | |
1578 | // this is really a global option for the APT library now | |
db09a1c5 | 1579 | if (!TransientNetworkFailure && !Failed && ListCleanup == true && |
b7c5ca8c | 1580 | (_config->FindB("APT::Get::List-Cleanup",true) == true && |
760d4968 MV |
1581 | _config->FindB("APT::List-Cleanup",true) == true)) |
1582 | { | |
1583 | if (Fetcher.Clean(_config->FindDir("Dir::State::lists")) == false || | |
1584 | Fetcher.Clean(_config->FindDir("Dir::State::lists") + "partial/") == false) | |
1585 | // something went wrong with the clean | |
1586 | return false; | |
1587 | } | |
1588 | ||
1589 | if (TransientNetworkFailure == true) | |
196c511c | 1590 | _error->Warning(_("Some index files failed to download. They have been ignored, or old ones used instead.")); |
760d4968 | 1591 | else if (Failed == true) |
196c511c | 1592 | return _error->Error(_("Some index files failed to download. They have been ignored, or old ones used instead.")); |
760d4968 MV |
1593 | |
1594 | ||
e06c72cd | 1595 | // Run the success scripts if all was fine |
db09a1c5 DK |
1596 | if (RunUpdateScripts == true) |
1597 | { | |
1598 | if(!TransientNetworkFailure && !Failed) | |
1599 | RunScripts("APT::Update::Post-Invoke-Success"); | |
e06c72cd | 1600 | |
db09a1c5 DK |
1601 | // Run the other scripts |
1602 | RunScripts("APT::Update::Post-Invoke"); | |
1603 | } | |
760d4968 MV |
1604 | return true; |
1605 | } | |
1606 | /*}}}*/ |