21 #include <boost/static_assert.hpp> 23 #define ZYPP_USE_RESOLVER_INTERNALS 38 #define MAXSOLVERRUNS 5 43 #undef ZYPP_BASE_LOGGER_LOGGROUP 44 #define ZYPP_BASE_LOGGER_LOGGROUP "zypp::solver" 62 os <<
"<resolver>" << endl;
63 #define OUTS(t) os << " " << #t << ":\t" << t << endl; 67 OUTS( _onlyRequires );
68 OUTS( _solveSrcPackages );
69 OUTS( _cleandepsOnRemove );
70 OUTS( _ignoreAlreadyRecommended );
72 return os <<
"<resolver/>";
81 , _poolchanged(_pool.serial() )
82 , _upgradeMode (
false)
86 , _solveSrcPackages (
false )
88 , _ignoreAlreadyRecommended (
true )
91 _satResolver =
new SATResolver(_pool, satPool.get());
106 #define ZOLV_FLAG_TRIBOOL( ZSETTER, ZGETTER, ZVARNAME, ZVARDEFAULT ) \ 107 void Resolver::ZSETTER( TriBool state_r ) \ 108 { _satResolver->ZVARNAME = indeterminate(state_r) ? ZVARDEFAULT : bool(state_r); } \ 109 bool Resolver::ZGETTER() const \ 110 { return _satResolver->ZVARNAME; } \ 117 ZOLV_FLAG_TRIBOOL( setAllowArchChange, allowArchChange, _allowarchchange, false )
125 #undef ZOLV_FLAG_TRIBOOL 148 _extra_requires.clear();
149 _extra_conflicts.clear();
152 _isInstalledBy.clear();
154 _satifiedByInstalled.clear();
155 _installedSatisfied.clear();
162 return resolvePool();
168 return _satResolver->doUpdate();
172 {
return _satResolver->problematicUpdateItems(); }
174 void Resolver::addExtraRequire(
const Capability & capability )
175 { _extra_requires.insert (capability); }
177 void Resolver::removeExtraRequire(
const Capability & capability )
178 { _extra_requires.erase (capability); }
180 void Resolver::addExtraConflict(
const Capability & capability )
181 { _extra_conflicts.insert (capability); }
183 void Resolver::removeExtraConflict(
const Capability & capability )
184 { _extra_conflicts.erase (capability); }
186 void Resolver::removeQueueItem( SolverQueueItem_Ptr item )
189 for (SolverQueueItemList::const_iterator iter = _added_queue_items.begin();
190 iter != _added_queue_items.end(); iter++) {
192 _added_queue_items.remove(*iter);
198 _removed_queue_items.push_back (item);
199 _removed_queue_items.unique ();
203 void Resolver::addQueueItem( SolverQueueItem_Ptr item )
206 for (SolverQueueItemList::const_iterator iter = _removed_queue_items.begin();
207 iter != _removed_queue_items.end(); iter++) {
209 _removed_queue_items.remove(*iter);
215 _added_queue_items.push_back (item);
216 _added_queue_items.unique ();
220 void Resolver::addWeak(
const PoolItem & item )
221 { _addWeak.push_back( item ); }
259 DBG <<
"Resolver::verifySystem()" << endl;
265 functor::functorRef<bool,PoolItem>(resetting) );
267 return resolvePool();
276 MIL <<
"*** undo ***" << endl;
279 functor::functorRef<bool,PoolItem>(info) );
284 _removed_queue_items.clear();
285 _added_queue_items.clear();
290 void Resolver::solverInit()
293 static bool poolDumped =
false;
294 MIL <<
"-------------- Calling SAT Solver -------------------" << endl;
295 if ( getenv(
"ZYPP_FULLLOG") ) {
296 Testcase testcase(
"/var/log/YaST2/autoTestcase");
298 testcase.createTestcase (*
this,
true,
false);
301 testcase.createTestcase (*
this,
false,
false);
305 _satResolver->setFixsystem ( isVerifyingMode() );
306 _satResolver->setIgnorealreadyrecommended ( ignoreAlreadyRecommended() );
307 _satResolver->setOnlyRequires ( onlyRequires() );
308 _satResolver->setUpdatesystem (_updateMode);
309 _satResolver->setSolveSrcPackages ( solveSrcPackages() );
310 _satResolver->setCleandepsOnRemove ( cleandepsOnRemove() );
312 _satResolver->setDistupgrade (_upgradeMode);
315 _satResolver->setDistupgrade_removeunsupported (
false);
319 _isInstalledBy.clear();
321 _satifiedByInstalled.clear();
322 _installedSatisfied.clear();
328 return _satResolver->resolvePool(_extra_requires, _extra_conflicts, _addWeak, _upgradeRepos );
336 for (SolverQueueItemList::const_iterator iter = _removed_queue_items.begin();
337 iter != _removed_queue_items.end(); iter++) {
338 for (SolverQueueItemList::const_iterator iterQueue = queue.begin(); iterQueue != queue.end(); iterQueue++) {
339 if ( (*iterQueue)->cmp(*iter) == 0) {
340 MIL <<
"remove from queue" << *iter;
341 queue.remove(*iterQueue);
347 for (SolverQueueItemList::const_iterator iter = _added_queue_items.begin();
348 iter != _added_queue_items.end(); iter++) {
350 for (SolverQueueItemList::const_iterator iterQueue = queue.begin(); iterQueue != queue.end(); iterQueue++) {
351 if ( (*iterQueue)->cmp(*iter) == 0) {
357 MIL <<
"add to queue" << *iter;
358 queue.push_back(*iter);
364 _removed_queue_items.clear();
365 _added_queue_items.clear();
367 return _satResolver->resolveQueue(queue, _addWeak);
374 ret.autoInstalled( _satResolver->autoInstalled() );
384 MIL <<
"Resolver::problems()" << endl;
385 return _satResolver->problems();
390 for ( ProblemSolution_Ptr solution : solutions )
392 if ( ! applySolution( *solution ) )
397 bool Resolver::applySolution(
const ProblemSolution & solution )
400 DBG <<
"apply solution " << solution << endl;
401 for ( SolutionAction_Ptr action : solution.actions() )
403 if ( ! action->execute( *
this ) )
405 WAR <<
"apply solution action failed: " << action << endl;
415 void Resolver::collectResolverInfo()
418 && _isInstalledBy.empty()
419 && _installs.empty()) {
422 PoolItemList itemsToInstall = _satResolver->resultItemsToInstall();
424 for (PoolItemList::const_iterator instIter = itemsToInstall.begin();
425 instIter != itemsToInstall.end(); instIter++) {
427 for (Capabilities::const_iterator capIt = (*instIter)->dep (
Dep::REQUIRES).begin(); capIt != (*instIter)->dep (
Dep::REQUIRES).end(); ++capIt)
429 sat::WhatProvides possibleProviders(*capIt);
430 for_( iter, possibleProviders.begin(), possibleProviders.end() ) {
435 bool alreadySetForInstallation =
false;
436 ItemCapKindMap::const_iterator pos = _isInstalledBy.find(provider);
437 while (pos != _isInstalledBy.end()
438 && pos->first == provider
440 alreadySetForInstallation =
true;
441 ItemCapKind capKind = pos->second;
442 if (capKind.item() == *instIter) found =
true;
447 && provider.status().isToBeInstalled()) {
448 if (provider.status().isBySolver()) {
449 ItemCapKind capKindisInstalledBy( *instIter, *capIt,
Dep::REQUIRES, !alreadySetForInstallation );
450 _isInstalledBy.insert (make_pair( provider, capKindisInstalledBy));
453 ItemCapKind capKindisInstalledBy( *instIter, *capIt,
Dep::REQUIRES,
false );
454 _isInstalledBy.insert (make_pair( provider, capKindisInstalledBy));
456 ItemCapKind capKindisInstalledBy( provider, *capIt,
Dep::REQUIRES, !alreadySetForInstallation );
457 _installs.insert (make_pair( *instIter, capKindisInstalledBy));
460 if (provider.status().staysInstalled()) {
461 ItemCapKind capKindisInstalledBy( provider, *capIt,
Dep::REQUIRES,
false );
462 _satifiedByInstalled.insert (make_pair( *instIter, capKindisInstalledBy));
464 ItemCapKind installedSatisfied( *instIter, *capIt,
Dep::REQUIRES,
false );
465 _installedSatisfied.insert (make_pair( provider, installedSatisfied));
470 if (!(_satResolver->onlyRequires())) {
474 sat::WhatProvides possibleProviders(*capIt);
475 for_( iter, possibleProviders.begin(), possibleProviders.end() ) {
480 bool alreadySetForInstallation =
false;
481 ItemCapKindMap::const_iterator pos = _isInstalledBy.find(provider);
482 while (pos != _isInstalledBy.end()
483 && pos->first == provider
485 alreadySetForInstallation =
true;
486 ItemCapKind capKind = pos->second;
487 if (capKind.item() == *instIter) found =
true;
492 && provider.status().isToBeInstalled()) {
493 if (provider.status().isBySolver()) {
494 ItemCapKind capKindisInstalledBy( *instIter, *capIt,
Dep::RECOMMENDS, !alreadySetForInstallation );
495 _isInstalledBy.insert (make_pair( provider, capKindisInstalledBy));
498 ItemCapKind capKindisInstalledBy( *instIter, *capIt,
Dep::RECOMMENDS,
false );
499 _isInstalledBy.insert (make_pair( provider, capKindisInstalledBy));
501 ItemCapKind capKindisInstalledBy( provider, *capIt,
Dep::RECOMMENDS, !alreadySetForInstallation );
502 _installs.insert (make_pair( *instIter, capKindisInstalledBy));
505 if (provider.status().staysInstalled()) {
506 ItemCapKind capKindisInstalledBy( provider, *capIt,
Dep::RECOMMENDS,
false );
507 _satifiedByInstalled.insert (make_pair( *instIter, capKindisInstalledBy));
509 ItemCapKind installedSatisfied( *instIter, *capIt,
Dep::RECOMMENDS,
false );
510 _installedSatisfied.insert (make_pair( provider, installedSatisfied));
518 sat::WhatProvides possibleProviders(*capIt);
519 for_( iter, possibleProviders.begin(), possibleProviders.end() ) {
523 bool alreadySetForInstallation =
false;
524 ItemCapKindMap::const_iterator pos = _isInstalledBy.find(*instIter);
525 while (pos != _isInstalledBy.end()
526 && pos->first == *instIter
528 alreadySetForInstallation =
true;
529 ItemCapKind capKind = pos->second;
530 if (capKind.item() == provider) found =
true;
535 && instIter->status().isToBeInstalled()) {
536 if (instIter->status().isBySolver()) {
537 ItemCapKind capKindisInstalledBy( provider, *capIt,
Dep::SUPPLEMENTS, !alreadySetForInstallation );
538 _isInstalledBy.insert (make_pair( *instIter, capKindisInstalledBy));
541 ItemCapKind capKindisInstalledBy( provider, *capIt,
Dep::SUPPLEMENTS,
false );
542 _isInstalledBy.insert (make_pair( *instIter, capKindisInstalledBy));
544 ItemCapKind capKindisInstalledBy( *instIter, *capIt,
Dep::SUPPLEMENTS, !alreadySetForInstallation );
545 _installs.insert (make_pair( provider, capKindisInstalledBy));
548 if (instIter->status().staysInstalled()) {
549 ItemCapKind capKindisInstalledBy( *instIter, *capIt,
Dep::SUPPLEMENTS, !alreadySetForInstallation );
550 _satifiedByInstalled.insert (make_pair( provider, capKindisInstalledBy));
552 ItemCapKind installedSatisfied( provider, *capIt,
Dep::SUPPLEMENTS,
false );
553 _installedSatisfied.insert (make_pair( *instIter, installedSatisfied));
566 collectResolverInfo();
568 for (ItemCapKindMap::const_iterator iter = _isInstalledBy.find(item); iter != _isInstalledBy.end();) {
569 ItemCapKind info = iter->second;
570 PoolItem iterItem = iter->first;
571 if (iterItem == item) {
576 iter = _isInstalledBy.end();
585 collectResolverInfo();
587 for (ItemCapKindMap::const_iterator iter = _installs.find(item); iter != _installs.end();) {
588 ItemCapKind info = iter->second;
589 PoolItem iterItem = iter->first;
590 if (iterItem == item) {
595 iter = _installs.end();
604 collectResolverInfo();
606 for (ItemCapKindMap::const_iterator iter = _satifiedByInstalled.find(item); iter != _satifiedByInstalled.end();) {
607 ItemCapKind info = iter->second;
608 PoolItem iterItem = iter->first;
609 if (iterItem == item) {
614 iter = _satifiedByInstalled.end();
623 collectResolverInfo();
625 for (ItemCapKindMap::const_iterator iter = _installedSatisfied.find(item); iter != _installedSatisfied.end();) {
626 ItemCapKind info = iter->second;
627 PoolItem iterItem = iter->first;
628 if (iterItem == item) {
633 iter = _installedSatisfied.end();
void doUpdate()
Update to newest package.
solver::detail::ItemCapKindList installs(const PoolItem &item)
Gives information about WHICH additional items will be installed due the installation of an item...
std::list< ProblemSolution_Ptr > ProblemSolutionList
bool resolvePool()
Resolve package dependencies:
sat::Transaction getTransaction()
Return the Transaction computed by the last solver run.
bool operator()(PoolItem item)
static const Dep RECOMMENDS
static const Dep SUPPLEMENTS
static ZConfig & instance()
Singleton ctor.
virtual std::ostream & dumpOn(std::ostream &str) const
Overload to realize std::ostream & operator<<.
PoolItem find(const sat::Solvable &slv_r) const
Return the corresponding PoolItem.
ResolverFocus
The resolvers general attitude.
void setCleandepsOnRemove(bool yesno_r)
Cleanup when deleting packages.
ResStatus & status() const
Returns the current status.
UndoTransact(const ResStatus::TransactByValue &status)
void setOnlyRequires(bool yesno_r)
Setting whether required packages are installed ONLY So recommended packages, language packages and p...
#define for_(IT, BEG, END)
Convenient for-loops using iterator.
bool doUpgrade()
Do an distribution upgrade (DUP)
Request the standard behavior (as defined in zypp.conf or 'Job')
bool resetTransact(TransactByValue causer_r)
Not the same as setTransact( false ).
std::list< SolverQueueItem_Ptr > SolverQueueItemList
solver::detail::ItemCapKindList isInstalledBy(const PoolItem &item)
Gives information about WHO has pused an installation of an given item.
bool resolveQueue(solver::detail::SolverQueueItemList &queue)
Resolve package dependencies:
ResolverProblemList problems()
Return the dependency problems found by the last call to resolveDependencies().
boost::logic::tribool TriBool
3-state boolean logic (true, false and indeterminate).
solver::detail::ItemCapKindList installedSatisfied(const PoolItem &item)
Gives information about WHICH items require an already installed item.
solver::detail::ItemCapKindList satifiedByInstalled(const PoolItem &item)
Gives information about WHICH installed items are requested by the installation of an item...
std::list< ResolverProblem_Ptr > ResolverProblemList
static Pool instance()
Singleton ctor.
std::list< PoolItem > problematicUpdateItems() const
Unmaintained packages which does not fit to the updated system (broken dependencies) will be deleted...
ResolverFocus focus() const
ResStatus::TransactByValue resStatus
std::unary_function< PoolItem, bool > PoolItemFilterFunctor
Interim helper class to collect global options and settings.
static const Dep REQUIRES
bool operator()(PoolItem item)
Select PoolItem by transact.
bool setTransact(bool toTansact_r, TransactByValue causer_r)
Toggle between TRANSACT and KEEP_STATE.
void applySolutions(const ProblemSolutionList &solutions)
Apply problem solutions.
bool solver_onlyRequires() const
Solver regards required packages,patterns,...
static constexpr LoadFromPoolType loadFromPool
ResolverFocus solver_focus() const
The resolvers general attitude when resolving jobs.
bool solver_cleandepsOnRemove() const
Whether removing a package should also remove no longer needed requirements.
std::list< ItemCapKind > ItemCapKindList
ZOLV_FLAG_TRIBOOL(setAllowNameChange, allowNameChange, _allownamechange, true) ZOLV_FLAG_TRIBOOL(setAllowVendorChange
ResStatus::TransactByValue resStatus
bool verifySystem()
Resolve package dependencies:
DoTransact(const ResStatus::TransactByValue &status)
Combining sat::Solvable and ResStatus.
void setFocus(ResolverFocus focus_r)
Define the resolvers general attitude when resolving jobs.
int invokeOnEach(TIterator begin_r, TIterator end_r, TFilter filter_r, TFunction fnc_r)
Iterate through [begin_r,end_r) and invoke fnc_r on each item that passes filter_r.
Easy-to use interface to the ZYPP dependency resolver.
Resolver(const ResPool &pool)
Ctor.
static ResPool instance()
Singleton ctor.