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