21 #include <boost/static_assert.hpp> 23 #define ZYPP_USE_RESOLVER_INTERNALS 45 #define MAXSOLVERRUNS 5 67 os <<
"<resolver>" << endl;
68 #define OUTS(t) os << " " << #t << ":\t" << t << endl; 69 OUTS( _forceResolve );
73 OUTS( _onlyRequires );
74 OUTS( _allowVendorChange );
75 OUTS( _solveSrcPackages );
76 OUTS( _cleandepsOnRemove );
77 OUTS( _ignoreAlreadyRecommended );
79 return os <<
"<resolver/>";
88 , _poolchanged(_pool.serial() )
89 , _forceResolve (
false)
90 , _upgradeMode (
false)
95 , _solveSrcPackages (
false )
97 , _ignoreAlreadyRecommended (
true )
101 _satResolver =
new SATResolver(_pool, satPool.get());
112 #define ZOLV_FLAG_TRIBOOL( ZSETTER, ZGETTER, ZVARNAME, ZVARDEFAULT ) \ 113 void Resolver::ZSETTER( TriBool state_r ) \ 114 { _satResolver->ZVARNAME = indeterminate(state_r) ? ZVARDEFAULT : bool(state_r); } \ 115 bool Resolver::ZGETTER() const \ 116 { return _satResolver->ZVARNAME; } \ 123 #undef ZOLV_FLAG_TRIBOOL 151 _extra_requires.clear();
152 _extra_conflicts.clear();
155 _isInstalledBy.clear();
157 _satifiedByInstalled.clear();
158 _installedSatisfied.clear();
165 return resolvePool();
171 return _satResolver->doUpdate();
175 {
return _satResolver->problematicUpdateItems(); }
177 void Resolver::addExtraRequire(
const Capability & capability )
178 { _extra_requires.insert (capability); }
180 void Resolver::removeExtraRequire(
const Capability & capability )
181 { _extra_requires.erase (capability); }
183 void Resolver::addExtraConflict(
const Capability & capability )
184 { _extra_conflicts.insert (capability); }
186 void Resolver::removeExtraConflict(
const Capability & capability )
187 { _extra_conflicts.erase (capability); }
189 void Resolver::removeQueueItem( SolverQueueItem_Ptr item )
192 for (SolverQueueItemList::const_iterator iter = _added_queue_items.begin();
193 iter != _added_queue_items.end(); iter++) {
195 _added_queue_items.remove(*iter);
201 _removed_queue_items.push_back (item);
202 _removed_queue_items.unique ();
206 void Resolver::addQueueItem( SolverQueueItem_Ptr item )
209 for (SolverQueueItemList::const_iterator iter = _removed_queue_items.begin();
210 iter != _removed_queue_items.end(); iter++) {
212 _removed_queue_items.remove(*iter);
218 _added_queue_items.push_back (item);
219 _added_queue_items.unique ();
223 void Resolver::addWeak(
const PoolItem & item )
224 { _addWeak.push_back( item ); }
262 DBG <<
"Resolver::verifySystem()" << endl;
268 functor::functorRef<bool,PoolItem>(resetting) );
270 return resolvePool();
279 MIL <<
"*** undo ***" << endl;
282 functor::functorRef<bool,PoolItem>(info) );
287 _removed_queue_items.clear();
288 _added_queue_items.clear();
293 void Resolver::solverInit()
296 static bool poolDumped =
false;
297 MIL <<
"-------------- Calling SAT Solver -------------------" << endl;
298 if ( getenv(
"ZYPP_FULLLOG") ) {
299 Testcase testcase(
"/var/log/YaST2/autoTestcase");
301 testcase.createTestcase (*
this,
true,
false);
304 testcase.createTestcase (*
this,
false,
false);
308 _satResolver->setFixsystem ( isVerifyingMode() );
309 _satResolver->setIgnorealreadyrecommended ( ignoreAlreadyRecommended() );
310 _satResolver->setOnlyRequires ( onlyRequires() );
311 _satResolver->setAllowdowngrade (
false);
312 _satResolver->setAllowarchchange (
false);
313 _satResolver->setAllowvendorchange ( allowVendorChange() );
314 _satResolver->setAllowuninstall ( forceResolve() );
315 _satResolver->setUpdatesystem (
false);
316 _satResolver->setNoupdateprovide (
false);
317 _satResolver->setDosplitprovides (
true);
318 _satResolver->setSolveSrcPackages ( solveSrcPackages() );
319 _satResolver->setCleandepsOnRemove ( cleandepsOnRemove() );
321 _satResolver->setDistupgrade (_upgradeMode);
324 _satResolver->setDistupgrade_removeunsupported (
false);
328 _isInstalledBy.clear();
330 _satifiedByInstalled.clear();
331 _installedSatisfied.clear();
337 return _satResolver->resolvePool(_extra_requires, _extra_conflicts, _addWeak, _upgradeRepos );
345 for (SolverQueueItemList::const_iterator iter = _removed_queue_items.begin();
346 iter != _removed_queue_items.end(); iter++) {
347 for (SolverQueueItemList::const_iterator iterQueue = queue.begin(); iterQueue != queue.end(); iterQueue++) {
348 if ( (*iterQueue)->cmp(*iter) == 0) {
349 MIL <<
"remove from queue" << *iter;
350 queue.remove(*iterQueue);
356 for (SolverQueueItemList::const_iterator iter = _added_queue_items.begin();
357 iter != _added_queue_items.end(); iter++) {
359 for (SolverQueueItemList::const_iterator iterQueue = queue.begin(); iterQueue != queue.end(); iterQueue++) {
360 if ( (*iterQueue)->cmp(*iter) == 0) {
366 MIL <<
"add to queue" << *iter;
367 queue.push_back(*iter);
373 _removed_queue_items.clear();
374 _added_queue_items.clear();
376 return _satResolver->resolveQueue(queue, _addWeak);
393 MIL <<
"Resolver::problems()" << endl;
394 return _satResolver->problems();
399 for ( ProblemSolution_Ptr solution : solutions )
401 if ( ! applySolution( *solution ) )
409 DBG <<
"apply solution " << solution << endl;
410 for ( SolutionAction_Ptr action : solution.
actions() )
412 if ( ! action->execute( *
this ) )
414 WAR <<
"apply solution action failed: " << action << endl;
424 void Resolver::collectResolverInfo()
427 && _isInstalledBy.empty()
428 && _installs.empty()) {
431 PoolItemList itemsToInstall = _satResolver->resultItemsToInstall();
433 for (PoolItemList::const_iterator instIter = itemsToInstall.begin();
434 instIter != itemsToInstall.end(); instIter++) {
439 for_( iter, possibleProviders.
begin(), possibleProviders.
end() ) {
444 bool alreadySetForInstallation =
false;
445 ItemCapKindMap::const_iterator pos = _isInstalledBy.find(provider);
446 while (pos != _isInstalledBy.end()
447 && pos->first == provider
449 alreadySetForInstallation =
true;
450 ItemCapKind capKind = pos->second;
451 if (capKind.item() == *instIter) found =
true;
458 ItemCapKind capKindisInstalledBy( *instIter, *capIt,
Dep::REQUIRES, !alreadySetForInstallation );
459 _isInstalledBy.insert (make_pair( provider, capKindisInstalledBy));
462 ItemCapKind capKindisInstalledBy( *instIter, *capIt,
Dep::REQUIRES,
false );
463 _isInstalledBy.insert (make_pair( provider, capKindisInstalledBy));
465 ItemCapKind capKindisInstalledBy( provider, *capIt,
Dep::REQUIRES, !alreadySetForInstallation );
466 _installs.insert (make_pair( *instIter, capKindisInstalledBy));
470 ItemCapKind capKindisInstalledBy( provider, *capIt,
Dep::REQUIRES,
false );
471 _satifiedByInstalled.insert (make_pair( *instIter, capKindisInstalledBy));
473 ItemCapKind installedSatisfied( *instIter, *capIt,
Dep::REQUIRES,
false );
474 _installedSatisfied.insert (make_pair( provider, installedSatisfied));
479 if (!(_satResolver->onlyRequires())) {
484 for_( iter, possibleProviders.
begin(), possibleProviders.
end() ) {
489 bool alreadySetForInstallation =
false;
490 ItemCapKindMap::const_iterator pos = _isInstalledBy.find(provider);
491 while (pos != _isInstalledBy.end()
492 && pos->first == provider
494 alreadySetForInstallation =
true;
495 ItemCapKind capKind = pos->second;
496 if (capKind.item() == *instIter) found =
true;
503 ItemCapKind capKindisInstalledBy( *instIter, *capIt,
Dep::RECOMMENDS, !alreadySetForInstallation );
504 _isInstalledBy.insert (make_pair( provider, capKindisInstalledBy));
507 ItemCapKind capKindisInstalledBy( *instIter, *capIt,
Dep::RECOMMENDS,
false );
508 _isInstalledBy.insert (make_pair( provider, capKindisInstalledBy));
510 ItemCapKind capKindisInstalledBy( provider, *capIt,
Dep::RECOMMENDS, !alreadySetForInstallation );
511 _installs.insert (make_pair( *instIter, capKindisInstalledBy));
515 ItemCapKind capKindisInstalledBy( provider, *capIt,
Dep::RECOMMENDS,
false );
516 _satifiedByInstalled.insert (make_pair( *instIter, capKindisInstalledBy));
518 ItemCapKind installedSatisfied( *instIter, *capIt,
Dep::RECOMMENDS,
false );
519 _installedSatisfied.insert (make_pair( provider, installedSatisfied));
528 for_( iter, possibleProviders.
begin(), possibleProviders.
end() ) {
532 bool alreadySetForInstallation =
false;
533 ItemCapKindMap::const_iterator pos = _isInstalledBy.find(*instIter);
534 while (pos != _isInstalledBy.end()
535 && pos->first == *instIter
537 alreadySetForInstallation =
true;
538 ItemCapKind capKind = pos->second;
539 if (capKind.item() == provider) found =
true;
544 && instIter->status().isToBeInstalled()) {
545 if (instIter->status().isBySolver()) {
546 ItemCapKind capKindisInstalledBy( provider, *capIt,
Dep::SUPPLEMENTS, !alreadySetForInstallation );
547 _isInstalledBy.insert (make_pair( *instIter, capKindisInstalledBy));
550 ItemCapKind capKindisInstalledBy( provider, *capIt,
Dep::SUPPLEMENTS,
false );
551 _isInstalledBy.insert (make_pair( *instIter, capKindisInstalledBy));
553 ItemCapKind capKindisInstalledBy( *instIter, *capIt,
Dep::SUPPLEMENTS, !alreadySetForInstallation );
554 _installs.insert (make_pair( provider, capKindisInstalledBy));
557 if (instIter->status().staysInstalled()) {
558 ItemCapKind capKindisInstalledBy( *instIter, *capIt,
Dep::SUPPLEMENTS, !alreadySetForInstallation );
559 _satifiedByInstalled.insert (make_pair( provider, capKindisInstalledBy));
561 ItemCapKind installedSatisfied( provider, *capIt,
Dep::SUPPLEMENTS,
false );
562 _installedSatisfied.insert (make_pair( *instIter, installedSatisfied));
575 collectResolverInfo();
577 for (ItemCapKindMap::const_iterator iter = _isInstalledBy.find(item); iter != _isInstalledBy.end();) {
578 ItemCapKind info = iter->second;
580 if (iterItem == item) {
585 iter = _isInstalledBy.end();
594 collectResolverInfo();
596 for (ItemCapKindMap::const_iterator iter = _installs.find(item); iter != _installs.end();) {
597 ItemCapKind info = iter->second;
599 if (iterItem == item) {
604 iter = _installs.end();
613 collectResolverInfo();
615 for (ItemCapKindMap::const_iterator iter = _satifiedByInstalled.find(item); iter != _satifiedByInstalled.end();) {
616 ItemCapKind info = iter->second;
618 if (iterItem == item) {
623 iter = _satifiedByInstalled.end();
632 collectResolverInfo();
634 for (ItemCapKindMap::const_iterator iter = _installedSatisfied.find(item); iter != _installedSatisfied.end();) {
635 ItemCapKind info = iter->second;
637 if (iterItem == item) {
642 iter = _installedSatisfied.end();
StringQueue autoInstalled() const
Return the ident strings of all packages that would be auto-installed after the transaction is run...
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)
Container of Solvable providing a Capability (read only).
static const Dep RECOMMENDS
static const Dep SUPPLEMENTS
std::list< PoolItem > problematicUpdateItems() const
Unmaintained packages which does not fit to the updated system (broken dependencies) will be deleted...
static ZConfig & instance()
Singleton ctor.
void setCleandepsOnRemove(bool yesno_r)
Cleanup when deleting packages.
void setAllowVendorChange(bool yesno_r)
Setting whether the solver should allow or disallow vendor changes.
UndoTransact(const ResStatus::TransactByValue &status)
Libsolv transaction wrapper.
#define for_(IT, BEG, END)
Convenient for-loops using iterator.
bool doUpgrade()
Do an distribution upgrade (DUP)
bool resetTransact(TransactByValue causer_r)
Not the same as setTransact( false ).
bool solver_cleandepsOnRemove() const
Whether removing a package should also remove no longer needed requirements.
void setOnlyRequires(bool yesno_r)
Setting whether required packages are installed ONLY So recommended packages, language packages and p...
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.
const_iterator begin() const
Iterator pointing to the first Solvable.
const_iterator end() const
Iterator pointing behind the last Solvable.
ResStatus::TransactByValue resStatus
std::unary_function< PoolItem, bool > PoolItemFilterFunctor
Interim helper class to collect global options and settings.
virtual std::ostream & dumpOn(std::ostream &str) const
Overload to realize std::ostream & operator<<.
static const Dep REQUIRES
ResStatus & status() const
Returns the current status.
ZOLV_FLAG_TRIBOOL(dupSetAllowDowngrade, dupAllowDowngrade, _dup_allowdowngrade, ZConfig::instance().solver_dupAllowDowngrade()) ZOLV_FLAG_TRIBOOL(dupSetAllowNameChange
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_allowVendorChange() const
Whether vendor check is by default enabled.
bool solver_onlyRequires() const
Solver regards required packages,patterns,...
static constexpr LoadFromPoolType loadFromPool
std::list< ItemCapKind > ItemCapKindList
ResStatus::TransactByValue resStatus
const SolutionActionList & actions() const
Return the list of actions forming this solution.
bool isToBeInstalled() const
bool verifySystem()
Resolve package dependencies:
DoTransact(const ResStatus::TransactByValue &status)
Combining sat::Solvable and ResStatus.
PoolItem find(const sat::Solvable &slv_r) const
Return the corresponding PoolItem.
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.
Class representing one possible solution to a problem found during resolving.
Resolver(const ResPool &pool)
Ctor.
bool staysInstalled() const
static ResPool instance()
Singleton ctor.