1 // -*- mode: cpp; mode: fold -*-
3 // $Id: packagemanager.cc,v 1.30 2003/04/27 03:04:15 doogie Exp $
4 /* ######################################################################
6 Package Manager - Abstacts the package manager
8 More work is needed in the area of transitioning provides, ie exim
9 replacing smail. This can cause interesing side effects.
11 Other cases involving conflicts+replaces should be tested.
13 ##################################################################### */
15 // Include Files /*{{{*/
18 #include <apt-pkg/packagemanager.h>
19 #include <apt-pkg/orderlist.h>
20 #include <apt-pkg/depcache.h>
21 #include <apt-pkg/error.h>
22 #include <apt-pkg/version.h>
23 #include <apt-pkg/acquire-item.h>
24 #include <apt-pkg/algorithms.h>
25 #include <apt-pkg/configuration.h>
26 #include <apt-pkg/sptr.h>
34 bool pkgPackageManager::SigINTStop
= false;
36 // PM::PackageManager - Constructor /*{{{*/
37 // ---------------------------------------------------------------------
39 pkgPackageManager::pkgPackageManager(pkgDepCache
*pCache
) : Cache(*pCache
)
41 FileNames
= new string
[Cache
.Head().PackageCount
];
43 Debug
= _config
->FindB("Debug::pkgPackageManager",false);
46 // PM::PackageManager - Destructor /*{{{*/
47 // ---------------------------------------------------------------------
49 pkgPackageManager::~pkgPackageManager()
55 // PM::GetArchives - Queue the archives for download /*{{{*/
56 // ---------------------------------------------------------------------
58 bool pkgPackageManager::GetArchives(pkgAcquire
*Owner
,pkgSourceList
*Sources
,
61 if (CreateOrderList() == false)
65 _config
->FindB("PackageManager::UnpackAll",true) ?
66 List
->OrderUnpack() : List
->OrderCritical();
67 if (ordering
== false)
68 return _error
->Error("Internal ordering error");
70 for (pkgOrderList::iterator I
= List
->begin(); I
!= List
->end(); ++I
)
72 PkgIterator
Pkg(Cache
,*I
);
73 FileNames
[Pkg
->ID
] = string();
75 // Skip packages to erase
76 if (Cache
[Pkg
].Delete() == true)
79 // Skip Packages that need configure only.
80 if (Pkg
.State() == pkgCache::PkgIterator::NeedsConfigure
&&
81 Cache
[Pkg
].Keep() == true)
84 // Skip already processed packages
85 if (List
->IsNow(Pkg
) == false)
88 new pkgAcqArchive(Owner
,Sources
,Recs
,Cache
[Pkg
].InstVerIter(Cache
),
95 // PM::FixMissing - Keep all missing packages /*{{{*/
96 // ---------------------------------------------------------------------
97 /* This is called to correct the installation when packages could not
99 bool pkgPackageManager::FixMissing()
101 pkgDepCache::ActionGroup
group(Cache
);
102 pkgProblemResolver
Resolve(&Cache
);
103 List
->SetFileList(FileNames
);
106 for (PkgIterator I
= Cache
.PkgBegin(); I
.end() == false; ++I
)
108 if (List
->IsMissing(I
) == false)
111 // Okay, this file is missing and we need it. Mark it for keep
113 Cache
.MarkKeep(I
, false, false);
116 // We have to empty the list otherwise it will not have the new changes
123 // Now downgrade everything that is broken
124 return Resolve
.ResolveByKeep() == true && Cache
.BrokenCount() == 0;
127 // PM::ImmediateAdd - Add the immediate flag recursivly /*{{{*/
128 // ---------------------------------------------------------------------
129 /* This adds the immediate flag to the pkg and recursively to the
132 void pkgPackageManager::ImmediateAdd(PkgIterator I
, bool UseInstallVer
, unsigned const int &Depth
)
138 if(Cache
[I
].InstallVer
== 0)
140 D
= Cache
[I
].InstVerIter(Cache
).DependsList();
142 if (I
->CurrentVer
== 0)
144 D
= I
.CurrentVer().DependsList();
147 for ( /* nothing */ ; D
.end() == false; ++D
)
148 if (D
->Type
== pkgCache::Dep::Depends
|| D
->Type
== pkgCache::Dep::PreDepends
)
150 if(!List
->IsFlag(D
.TargetPkg(), pkgOrderList::Immediate
))
153 clog
<< OutputInDepth(Depth
) << "ImmediateAdd(): Adding Immediate flag to " << D
.TargetPkg() << " cause of " << D
.DepType() << " " << I
.Name() << endl
;
154 List
->Flag(D
.TargetPkg(),pkgOrderList::Immediate
);
155 ImmediateAdd(D
.TargetPkg(), UseInstallVer
, Depth
+ 1);
161 // PM::CreateOrderList - Create the ordering class /*{{{*/
162 // ---------------------------------------------------------------------
163 /* This populates the ordering list with all the packages that are
165 bool pkgPackageManager::CreateOrderList()
171 List
= new pkgOrderList(&Cache
);
173 NoImmConfigure
= !_config
->FindB("APT::Immediate-Configure",true);
174 ImmConfigureAll
= _config
->FindB("APT::Immediate-Configure-All",false);
176 if (Debug
&& ImmConfigureAll
)
177 clog
<< "CreateOrderList(): Adding Immediate flag for all packages because of APT::Immediate-Configure-All" << endl
;
179 // Generate the list of affected packages and sort it
180 for (PkgIterator I
= Cache
.PkgBegin(); I
.end() == false; ++I
)
182 // Ignore no-version packages
183 if (I
->VersionList
== 0)
186 // Mark the package and its dependends for immediate configuration
187 if ((((I
->Flags
& pkgCache::Flag::Essential
) == pkgCache::Flag::Essential
||
188 (I
->Flags
& pkgCache::Flag::Important
) == pkgCache::Flag::Important
) &&
189 NoImmConfigure
== false) || ImmConfigureAll
)
191 if(Debug
&& !ImmConfigureAll
)
192 clog
<< "CreateOrderList(): Adding Immediate flag for " << I
.Name() << endl
;
193 List
->Flag(I
,pkgOrderList::Immediate
);
195 if (!ImmConfigureAll
) {
196 // Look for other install packages to make immediate configurea
197 ImmediateAdd(I
, true);
199 // And again with the current version.
200 ImmediateAdd(I
, false);
205 if ((Cache
[I
].Keep() == true ||
206 Cache
[I
].InstVerIter(Cache
) == I
.CurrentVer()) &&
207 I
.State() == pkgCache::PkgIterator::NeedsNothing
&&
208 (Cache
[I
].iFlags
& pkgDepCache::ReInstall
) != pkgDepCache::ReInstall
&&
209 (I
.Purge() != false || Cache
[I
].Mode
!= pkgDepCache::ModeDelete
||
210 (Cache
[I
].iFlags
& pkgDepCache::Purge
) != pkgDepCache::Purge
))
213 // Append it to the list
220 // PM::DepAlwaysTrue - Returns true if this dep is irrelevent /*{{{*/
221 // ---------------------------------------------------------------------
222 /* The restriction on provides is to eliminate the case when provides
223 are transitioning between valid states [ie exim to smail] */
224 bool pkgPackageManager::DepAlwaysTrue(DepIterator D
)
226 if (D
.TargetPkg()->ProvidesList
!= 0)
229 if ((Cache
[D
] & pkgDepCache::DepInstall
) != 0 &&
230 (Cache
[D
] & pkgDepCache::DepNow
) != 0)
235 // PM::CheckRConflicts - Look for reverse conflicts /*{{{*/
236 // ---------------------------------------------------------------------
237 /* This looks over the reverses for a conflicts line that needs early
239 bool pkgPackageManager::CheckRConflicts(PkgIterator Pkg
,DepIterator D
,
242 for (;D
.end() == false; ++D
)
244 if (D
->Type
!= pkgCache::Dep::Conflicts
&&
245 D
->Type
!= pkgCache::Dep::Obsoletes
)
248 // The package hasnt been changed
249 if (List
->IsNow(Pkg
) == false)
252 // Ignore self conflicts, ignore conflicts from irrelevent versions
253 if (D
.IsIgnorable(Pkg
) || D
.ParentVer() != D
.ParentPkg().CurrentVer())
256 if (Cache
.VS().CheckDep(Ver
,D
->CompareOp
,D
.TargetVer()) == false)
259 if (EarlyRemove(D
.ParentPkg()) == false)
260 return _error
->Error("Reverse conflicts early remove for package '%s' failed",
266 // PM::ConfigureAll - Run the all out configuration /*{{{*/
267 // ---------------------------------------------------------------------
268 /* This configures every package. It is assumed they are all unpacked and
269 that the final configuration is valid. This is also used to catch packages
270 that have not been configured when using ImmConfigureAll */
271 bool pkgPackageManager::ConfigureAll()
273 pkgOrderList
OList(&Cache
);
275 // Populate the order list
276 for (pkgOrderList::iterator I
= List
->begin(); I
!= List
->end(); ++I
)
277 if (List
->IsFlag(pkgCache::PkgIterator(Cache
,*I
),
278 pkgOrderList::UnPacked
) == true)
281 if (OList
.OrderConfigure() == false)
284 std::string
const conf
= _config
->Find("PackageManager::Configure","all");
285 bool const ConfigurePkgs
= (conf
== "all");
287 // Perform the configuring
288 for (pkgOrderList::iterator I
= OList
.begin(); I
!= OList
.end(); ++I
)
290 PkgIterator
Pkg(Cache
,*I
);
292 /* Check if the package has been configured, this can happen if SmartConfigure
294 if (List
->IsFlag(Pkg
,pkgOrderList::Configured
)) continue;
296 if (ConfigurePkgs
== true && SmartConfigure(Pkg
, 0) == false) {
298 _error
->Error(_("Could not perform immediate configuration on '%s'. "
299 "Please see man 5 apt.conf under APT::Immediate-Configure for details. (%d)"),Pkg
.Name(),1);
301 _error
->Error("Internal error, packages left unconfigured. %s",Pkg
.Name());
305 List
->Flag(Pkg
,pkgOrderList::Configured
,pkgOrderList::States
);
311 // PM::SmartConfigure - Perform immediate configuration of the pkg /*{{{*/
312 // ---------------------------------------------------------------------
313 /* This function tries to put the system in a state where Pkg can be configured.
314 This involves checking each of Pkg's dependanies and unpacking and
315 configuring packages where needed.
317 Note on failure: This method can fail, without causing any problems.
318 This can happen when using Immediate-Configure-All, SmartUnPack may call
319 SmartConfigure, it may fail because of a complex dependancy situation, but
320 a error will only be reported if ConfigureAll fails. This is why some of the
321 messages this function reports on failure (return false;) as just warnings
322 only shown when debuging*/
323 bool pkgPackageManager::SmartConfigure(PkgIterator Pkg
, int const Depth
)
325 // If this is true, only check and correct and dependencies without the Loop flag
326 bool PkgLoop
= List
->IsFlag(Pkg
,pkgOrderList::Loop
);
329 VerIterator InstallVer
= VerIterator(Cache
,Cache
[Pkg
].InstallVer
);
330 clog
<< OutputInDepth(Depth
) << "SmartConfigure " << Pkg
.Name() << " (" << InstallVer
.VerStr() << ")";
332 clog
<< " (Only Correct Dependencies)";
336 VerIterator
const instVer
= Cache
[Pkg
].InstVerIter(Cache
);
338 /* Because of the ordered list, most dependencies should be unpacked,
339 however if there is a loop (A depends on B, B depends on A) this will not
340 be the case, so check for dependencies before configuring. */
342 for (DepIterator D
= instVer
.DependsList();
345 // Compute a single dependency element (glob or)
346 pkgCache::DepIterator Start
;
347 pkgCache::DepIterator End
;
350 if (End
->Type
== pkgCache::Dep::Depends
)
353 // Check for dependanices that have not been unpacked, probably due to loops.
354 while (End
->Type
== pkgCache::Dep::Depends
) {
356 VerIterator InstallVer
;
357 SPtrArray
<Version
*> VList
= Start
.AllTargets();
359 // Check through each version of each package that could satisfy this dependancy
360 for (Version
**I
= VList
; *I
!= 0; I
++) {
361 VerIterator
Ver(Cache
,*I
);
362 DepPkg
= Ver
.ParentPkg();
363 InstallVer
= VerIterator(Cache
,Cache
[DepPkg
].InstallVer
);
365 // Check if the current version of the package is avalible and will satisfy this dependancy
366 if (DepPkg
.CurrentVer() == Ver
&& List
->IsNow(DepPkg
) == true &&
367 !List
->IsFlag(DepPkg
,pkgOrderList::Removed
) && DepPkg
.State() == PkgIterator::NeedsNothing
)
373 // Check if the version that is going to be installed will satisfy the dependancy
374 if (Cache
[DepPkg
].InstallVer
== *I
) {
375 if (List
->IsFlag(DepPkg
,pkgOrderList::UnPacked
)) {
376 if (List
->IsFlag(DepPkg
,pkgOrderList::Loop
) && PkgLoop
) {
377 // This dependancy has already been dealt with by another SmartConfigure on Pkg
380 } else if (List
->IsFlag(Pkg
,pkgOrderList::Loop
)) {
381 /* Check for a loop to prevent one forming
382 If A depends on B and B depends on A, SmartConfigure will
383 just hop between them if this is not checked. Dont remove the
384 loop flag after finishing however as loop is already set.
385 This means that there is another SmartConfigure call for this
386 package and it will remove the loop flag */
387 Bad
= !SmartConfigure(DepPkg
, Depth
+ 1);
389 /* Check for a loop to prevent one forming
390 If A depends on B and B depends on A, SmartConfigure will
391 just hop between them if this is not checked */
392 List
->Flag(Pkg
,pkgOrderList::Loop
);
393 Bad
= !SmartConfigure(DepPkg
, Depth
+ 1);
394 List
->RmFlag(Pkg
,pkgOrderList::Loop
);
396 // If SmartConfigure was succesfull, Bad is false, so break
398 } else if (List
->IsFlag(DepPkg
,pkgOrderList::Configured
)) {
405 /* If the dependany is still not satisfied, try, if possible, unpacking a package to satisfy it */
406 if (InstallVer
!= 0 && Bad
) {
407 if (List
->IsNow(DepPkg
)) {
409 if (List
->IsFlag(Pkg
,pkgOrderList::Loop
))
412 std::clog
<< OutputInDepth(Depth
) << "Package " << Pkg
<< " loops in SmartConfigure" << std::endl
;
416 List
->Flag(Pkg
,pkgOrderList::Loop
);
418 cout
<< OutputInDepth(Depth
) << "Unpacking " << DepPkg
.Name() << " to avoid loop" << endl
;
419 SmartUnPack(DepPkg
, true, Depth
+ 1);
420 List
->RmFlag(Pkg
,pkgOrderList::Loop
);
426 if (Bad
&& Debug
&& List
->IsFlag(DepPkg
,pkgOrderList::Loop
) == false)
427 std::clog
<< OutputInDepth(Depth
) << "Could not satisfy dependencies for " << Pkg
.Name() << std::endl
;
437 _error
->Warning(_("Could not configure '%s'. "),Pkg
.Name());
441 if (PkgLoop
) return true;
443 static std::string
const conf
= _config
->Find("PackageManager::Configure","all");
444 static bool const ConfigurePkgs
= (conf
== "all" || conf
== "smart");
446 if (List
->IsFlag(Pkg
,pkgOrderList::Configured
))
447 return _error
->Error("Internal configure error on '%s'.", Pkg
.Name());
449 if (ConfigurePkgs
== true && Configure(Pkg
) == false)
452 List
->Flag(Pkg
,pkgOrderList::Configured
,pkgOrderList::States
);
454 if ((Cache
[Pkg
].InstVerIter(Cache
)->MultiArch
& pkgCache::Version::Same
) == pkgCache::Version::Same
)
455 for (PkgIterator P
= Pkg
.Group().PackageList();
456 P
.end() == false; P
= Pkg
.Group().NextPkg(P
))
458 if (Pkg
== P
|| List
->IsFlag(P
,pkgOrderList::Configured
) == true ||
459 Cache
[P
].InstallVer
== 0 || (P
.CurrentVer() == Cache
[P
].InstallVer
&&
460 (Cache
[Pkg
].iFlags
& pkgDepCache::ReInstall
) != pkgDepCache::ReInstall
))
462 SmartConfigure(P
, (Depth
+1));
466 if (List
->IsFlag(Pkg
,pkgOrderList::Configured
) == false)
467 return _error
->Error(_("Could not configure '%s'. "),Pkg
.Name());
472 // PM::EarlyRemove - Perform removal of packages before their time /*{{{*/
473 // ---------------------------------------------------------------------
474 /* This is called to deal with conflicts arising from unpacking */
475 bool pkgPackageManager::EarlyRemove(PkgIterator Pkg
)
477 if (List
->IsNow(Pkg
) == false)
480 // Already removed it
481 if (List
->IsFlag(Pkg
,pkgOrderList::Removed
) == true)
484 // Woops, it will not be re-installed!
485 if (List
->IsFlag(Pkg
,pkgOrderList::InList
) == false)
488 // Essential packages get special treatment
489 bool IsEssential
= false;
490 if ((Pkg
->Flags
& pkgCache::Flag::Essential
) != 0)
493 /* Check for packages that are the dependents of essential packages and
495 if (Pkg
->CurrentVer
!= 0)
497 for (DepIterator D
= Pkg
.RevDependsList(); D
.end() == false &&
498 IsEssential
== false; ++D
)
499 if (D
->Type
== pkgCache::Dep::Depends
|| D
->Type
== pkgCache::Dep::PreDepends
)
500 if ((D
.ParentPkg()->Flags
& pkgCache::Flag::Essential
) != 0)
504 if (IsEssential
== true)
506 if (_config
->FindB("APT::Force-LoopBreak",false) == false)
507 return _error
->Error(_("This installation run will require temporarily "
508 "removing the essential package %s due to a "
509 "Conflicts/Pre-Depends loop. This is often bad, "
510 "but if you really want to do it, activate the "
511 "APT::Force-LoopBreak option."),Pkg
.Name());
514 bool Res
= SmartRemove(Pkg
);
515 if (Cache
[Pkg
].Delete() == false)
516 List
->Flag(Pkg
,pkgOrderList::Removed
,pkgOrderList::States
);
521 // PM::SmartRemove - Removal Helper /*{{{*/
522 // ---------------------------------------------------------------------
524 bool pkgPackageManager::SmartRemove(PkgIterator Pkg
)
526 if (List
->IsNow(Pkg
) == false)
529 List
->Flag(Pkg
,pkgOrderList::Configured
,pkgOrderList::States
);
531 return Remove(Pkg
,(Cache
[Pkg
].iFlags
& pkgDepCache::Purge
) == pkgDepCache::Purge
);
534 // PM::SmartUnPack - Install helper /*{{{*/
535 // ---------------------------------------------------------------------
536 /* This puts the system in a state where it can Unpack Pkg, if Pkg is allready
537 unpacked, or when it has been unpacked, if Immediate==true it configures it. */
538 bool pkgPackageManager::SmartUnPack(PkgIterator Pkg
)
540 return SmartUnPack(Pkg
, true, 0);
542 bool pkgPackageManager::SmartUnPack(PkgIterator Pkg
, bool const Immediate
, int const Depth
)
544 bool PkgLoop
= List
->IsFlag(Pkg
,pkgOrderList::Loop
);
547 clog
<< OutputInDepth(Depth
) << "SmartUnPack " << Pkg
.Name();
548 VerIterator InstallVer
= VerIterator(Cache
,Cache
[Pkg
].InstallVer
);
549 if (Pkg
.CurrentVer() == 0)
550 cout
<< " (install version " << InstallVer
.VerStr() << ")";
552 cout
<< " (replace version " << Pkg
.CurrentVer().VerStr() << " with " << InstallVer
.VerStr() << ")";
554 cout
<< " (Only Perform PreUnpack Checks)";
558 VerIterator
const instVer
= Cache
[Pkg
].InstVerIter(Cache
);
560 /* PreUnpack Checks: This loop checks and attempts to rectify and problems that would prevent the package being unpacked.
561 It addresses: PreDepends, Conflicts, Obsoletes and Breaks (DpkgBreaks). Any resolutions that do not require it should
562 avoid configuration (calling SmartUnpack with Immediate=true), this is because when unpacking some packages with
563 complex dependancy structures, trying to configure some packages while breaking the loops can complicate things .
564 This will be either dealt with if the package is configured as a dependency of Pkg (if and when Pkg is configured),
565 or by the ConfigureAll call at the end of the for loop in OrderInstall. */
566 for (DepIterator D
= instVer
.DependsList();
569 // Compute a single dependency element (glob or)
570 pkgCache::DepIterator Start
;
571 pkgCache::DepIterator End
;
574 while (End
->Type
== pkgCache::Dep::PreDepends
)
577 clog
<< OutputInDepth(Depth
) << "PreDepends order for " << Pkg
.Name() << std::endl
;
579 // Look for possible ok targets.
580 SPtrArray
<Version
*> VList
= Start
.AllTargets();
582 for (Version
**I
= VList
; *I
!= 0 && Bad
== true; I
++)
584 VerIterator
Ver(Cache
,*I
);
585 PkgIterator Pkg
= Ver
.ParentPkg();
587 // See if the current version is ok
588 if (Pkg
.CurrentVer() == Ver
&& List
->IsNow(Pkg
) == true &&
589 Pkg
.State() == PkgIterator::NeedsNothing
)
593 clog
<< OutputInDepth(Depth
) << "Found ok package " << Pkg
.Name() << endl
;
598 // Look for something that could be configured.
599 for (Version
**I
= VList
; *I
!= 0 && Bad
== true; I
++)
601 VerIterator
Ver(Cache
,*I
);
602 PkgIterator Pkg
= Ver
.ParentPkg();
604 // Not the install version
605 if (Cache
[Pkg
].InstallVer
!= *I
||
606 (Cache
[Pkg
].Keep() == true && Pkg
.State() == PkgIterator::NeedsNothing
))
609 if (List
->IsFlag(Pkg
,pkgOrderList::Configured
)) {
614 // check if it needs unpack or if if configure is enough
615 if (!List
->IsFlag(Pkg
,pkgOrderList::UnPacked
))
618 clog
<< OutputInDepth(Depth
) << "Trying to SmartUnpack " << Pkg
.Name() << endl
;
619 // SmartUnpack with the ImmediateFlag to ensure its really ready
620 Bad
= !SmartUnPack(Pkg
, true, Depth
+ 1);
623 clog
<< OutputInDepth(Depth
) << "Trying to SmartConfigure " << Pkg
.Name() << endl
;
624 Bad
= !SmartConfigure(Pkg
, Depth
+ 1);
628 /* If this or element did not match then continue on to the
629 next or element until a matching element is found */
632 // This triggers if someone make a pre-depends/depend loop.
634 return _error
->Error("Couldn't configure pre-depend %s for %s, "
635 "probably a dependency cycle.",
636 End
.TargetPkg().Name(),Pkg
.Name());
643 if (End
->Type
== pkgCache::Dep::Conflicts
||
644 End
->Type
== pkgCache::Dep::Obsoletes
)
646 /* Look for conflicts. Two packages that are both in the install
647 state cannot conflict so we don't check.. */
648 SPtrArray
<Version
*> VList
= End
.AllTargets();
649 for (Version
**I
= VList
; *I
!= 0; I
++)
651 VerIterator
Ver(Cache
,*I
);
652 PkgIterator ConflictPkg
= Ver
.ParentPkg();
653 VerIterator
InstallVer(Cache
,Cache
[ConflictPkg
].InstallVer
);
655 // See if the current version is conflicting
656 if (ConflictPkg
.CurrentVer() == Ver
&& List
->IsNow(ConflictPkg
))
658 cout
<< OutputInDepth(Depth
) << Pkg
.Name() << " conflicts with " << ConflictPkg
.Name() << endl
;
659 /* If a loop is not present or has not yet been detected, attempt to unpack packages
660 to resolve this conflict. If there is a loop present, remove packages to resolve this conflict */
661 if (!List
->IsFlag(ConflictPkg
,pkgOrderList::Loop
)) {
662 if (Cache
[ConflictPkg
].Keep() == 0 && Cache
[ConflictPkg
].InstallVer
!= 0) {
664 cout
<< OutputInDepth(Depth
) << OutputInDepth(Depth
) << "Unpacking " << ConflictPkg
.Name() << " to prevent conflict" << endl
;
665 List
->Flag(Pkg
,pkgOrderList::Loop
);
666 SmartUnPack(ConflictPkg
,false, Depth
+ 1);
667 // Remove loop to allow it to be used later if needed
668 List
->RmFlag(Pkg
,pkgOrderList::Loop
);
670 if (EarlyRemove(ConflictPkg
) == false)
671 return _error
->Error("Internal Error, Could not early remove %s",ConflictPkg
.Name());
674 if (!List
->IsFlag(ConflictPkg
,pkgOrderList::Removed
)) {
676 cout
<< OutputInDepth(Depth
) << "Because of conficts knot, removing " << ConflictPkg
.Name() << " to conflict violation" << endl
;
677 if (EarlyRemove(ConflictPkg
) == false)
678 return _error
->Error("Internal Error, Could not early remove %s",ConflictPkg
.Name());
686 if (End
->Type
== pkgCache::Dep::DpkgBreaks
) {
687 SPtrArray
<Version
*> VList
= End
.AllTargets();
688 for (Version
**I
= VList
; *I
!= 0; I
++)
690 VerIterator
Ver(Cache
,*I
);
691 PkgIterator BrokenPkg
= Ver
.ParentPkg();
692 VerIterator
InstallVer(Cache
,Cache
[BrokenPkg
].InstallVer
);
693 if (BrokenPkg
.CurrentVer() != Ver
)
696 std::clog
<< OutputInDepth(Depth
) << " Ignore not-installed version " << Ver
.VerStr() << " of " << Pkg
.FullName() << " for " << End
<< std::endl
;
700 // Check if it needs to be unpacked
701 if (List
->IsFlag(BrokenPkg
,pkgOrderList::InList
) && Cache
[BrokenPkg
].Delete() == false &&
702 List
->IsNow(BrokenPkg
)) {
703 if (List
->IsFlag(BrokenPkg
,pkgOrderList::Loop
) && PkgLoop
) {
704 // This dependancy has already been dealt with by another SmartUnPack on Pkg
706 } else if (List
->IsFlag(Pkg
,pkgOrderList::Loop
)) {
707 /* Found a break, so unpack the package, but dont remove loop as already set.
708 This means that there is another SmartUnPack call for this
709 package and it will remove the loop flag. */
711 cout
<< OutputInDepth(Depth
) << " Unpacking " << BrokenPkg
.Name() << " to avoid break" << endl
;
713 SmartUnPack(BrokenPkg
, false, Depth
+ 1);
715 List
->Flag(Pkg
,pkgOrderList::Loop
);
716 // Found a break, so unpack the package
718 cout
<< OutputInDepth(Depth
) << " Unpacking " << BrokenPkg
.Name() << " to avoid break" << endl
;
720 SmartUnPack(BrokenPkg
, false, Depth
+ 1);
721 List
->RmFlag(Pkg
,pkgOrderList::Loop
);
725 // Check if a package needs to be removed
726 if (Cache
[BrokenPkg
].Delete() == true && !List
->IsFlag(BrokenPkg
,pkgOrderList::Configured
)) {
728 cout
<< OutputInDepth(Depth
) << " Removing " << BrokenPkg
.Name() << " to avoid break" << endl
;
729 SmartRemove(BrokenPkg
);
735 // Check for reverse conflicts.
736 if (CheckRConflicts(Pkg
,Pkg
.RevDependsList(),
737 instVer
.VerStr()) == false)
740 for (PrvIterator P
= instVer
.ProvidesList();
741 P
.end() == false; ++P
)
742 if (Pkg
->Group
!= P
.OwnerPkg()->Group
)
743 CheckRConflicts(Pkg
,P
.ParentPkg().RevDependsList(),P
.ProvideVersion());
748 List
->Flag(Pkg
,pkgOrderList::UnPacked
,pkgOrderList::States
);
750 if (Immediate
== true && (instVer
->MultiArch
& pkgCache::Version::Same
) == pkgCache::Version::Same
)
752 /* Do lockstep M-A:same unpacking in two phases:
753 First unpack all installed architectures, then the not installed.
754 This way we avoid that M-A: enabled packages are installed before
755 their older non-M-A enabled packages are replaced by newer versions */
756 bool const installed
= Pkg
->CurrentVer
!= 0;
757 if (installed
== true && Install(Pkg
,FileNames
[Pkg
->ID
]) == false)
759 for (PkgIterator P
= Pkg
.Group().PackageList();
760 P
.end() == false; P
= Pkg
.Group().NextPkg(P
))
762 if (P
->CurrentVer
== 0 || P
== Pkg
|| List
->IsFlag(P
,pkgOrderList::UnPacked
) == true ||
763 Cache
[P
].InstallVer
== 0 || (P
.CurrentVer() == Cache
[P
].InstallVer
&&
764 (Cache
[Pkg
].iFlags
& pkgDepCache::ReInstall
) != pkgDepCache::ReInstall
))
766 if (SmartUnPack(P
, false, Depth
+ 1) == false)
769 if (installed
== false && Install(Pkg
,FileNames
[Pkg
->ID
]) == false)
771 for (PkgIterator P
= Pkg
.Group().PackageList();
772 P
.end() == false; P
= Pkg
.Group().NextPkg(P
))
774 if (P
->CurrentVer
!= 0 || P
== Pkg
|| List
->IsFlag(P
,pkgOrderList::UnPacked
) == true ||
775 Cache
[P
].InstallVer
== 0 || (P
.CurrentVer() == Cache
[P
].InstallVer
&&
776 (Cache
[Pkg
].iFlags
& pkgDepCache::ReInstall
) != pkgDepCache::ReInstall
))
778 if (SmartUnPack(P
, false, Depth
+ 1) == false)
782 // packages which are already unpacked don't need to be unpacked again
783 else if (Pkg
.State() != pkgCache::PkgIterator::NeedsConfigure
&& Install(Pkg
,FileNames
[Pkg
->ID
]) == false)
786 if (Immediate
== true) {
787 // Perform immedate configuration of the package.
788 if (SmartConfigure(Pkg
, Depth
+ 1) == false)
789 _error
->Warning(_("Could not perform immediate configuration on '%s'. "
790 "Please see man 5 apt.conf under APT::Immediate-Configure for details. (%d)"),Pkg
.Name(),2);
796 // PM::OrderInstall - Installation ordering routine /*{{{*/
797 // ---------------------------------------------------------------------
799 pkgPackageManager::OrderResult
pkgPackageManager::OrderInstall()
801 if (CreateOrderList() == false)
807 clog
<< "Beginning to order" << endl
;
809 bool const ordering
=
810 _config
->FindB("PackageManager::UnpackAll",true) ?
811 List
->OrderUnpack(FileNames
) : List
->OrderCritical();
812 if (ordering
== false)
814 _error
->Error("Internal ordering error");
819 clog
<< "Done ordering" << endl
;
821 bool DoneSomething
= false;
822 for (pkgOrderList::iterator I
= List
->begin(); I
!= List
->end(); ++I
)
824 PkgIterator
Pkg(Cache
,*I
);
826 if (List
->IsNow(Pkg
) == false)
828 if (!List
->IsFlag(Pkg
,pkgOrderList::Configured
) && !NoImmConfigure
) {
829 if (SmartConfigure(Pkg
, 0) == false && Debug
)
830 _error
->Warning("Internal Error, Could not configure %s",Pkg
.Name());
831 // FIXME: The above warning message might need changing
834 clog
<< "Skipping already done " << Pkg
.Name() << endl
;
840 if (List
->IsMissing(Pkg
) == true)
843 clog
<< "Sequence completed at " << Pkg
.Name() << endl
;
844 if (DoneSomething
== false)
846 _error
->Error("Internal Error, ordering was unable to handle the media swap");
853 if (Cache
[Pkg
].Keep() == true &&
854 Pkg
.State() == pkgCache::PkgIterator::NeedsNothing
&&
855 (Cache
[Pkg
].iFlags
& pkgDepCache::ReInstall
) != pkgDepCache::ReInstall
)
857 _error
->Error("Internal Error, trying to manipulate a kept package (%s)",Pkg
.Name());
861 // Perform a delete or an install
862 if (Cache
[Pkg
].Delete() == true)
864 if (SmartRemove(Pkg
) == false)
868 if (SmartUnPack(Pkg
,List
->IsFlag(Pkg
,pkgOrderList::Immediate
),0) == false)
870 DoneSomething
= true;
872 if (ImmConfigureAll
) {
873 /* ConfigureAll here to pick up and packages left unconfigured becuase they were unpacked in the
874 "PreUnpack Checks" section */
880 // Final run through the configure phase
881 if (ConfigureAll() == false)
885 for (pkgOrderList::iterator I
= List
->begin(); I
!= List
->end(); ++I
)
887 if (List
->IsFlag(*I
,pkgOrderList::Configured
) == false)
889 _error
->Error("Internal error, packages left unconfigured. %s",
890 PkgIterator(Cache
,*I
).Name());
898 // PM::DoInstallPostFork - Does install part that happens after the fork /*{{{*/
899 // ---------------------------------------------------------------------
900 pkgPackageManager::OrderResult
901 pkgPackageManager::DoInstallPostFork(int statusFd
)
904 // FIXME: use SetCloseExec here once it taught about throwing
905 // exceptions instead of doing _exit(100) on failure
906 fcntl(statusFd
,F_SETFD
,FD_CLOEXEC
);
907 bool goResult
= Go(statusFd
);
908 if(goResult
== false)
914 // PM::DoInstall - Does the installation /*{{{*/
915 // ---------------------------------------------------------------------
916 /* This uses the filenames in FileNames and the information in the
917 DepCache to perform the installation of packages.*/
918 pkgPackageManager::OrderResult
pkgPackageManager::DoInstall(int statusFd
)
920 if(DoInstallPreFork() == Failed
)
923 return DoInstallPostFork(statusFd
);