23 #include <solv/repo_solv.h>
24 #include <solv/poolarch.h>
26 #include <solv/poolvendor.h>
27 #include <solv/policy.h>
28 #include <solv/bitmap.h>
29 #include <solv/queue.h>
32 #define ZYPP_USE_RESOLVER_INTERNALS
58 #define XDEBUG(x) do { if (base::logger::isExcessive()) XXX << x << std::endl;} while (0)
60 #undef ZYPP_BASE_LOGGER_LOGGROUP
61 #define ZYPP_BASE_LOGGER_LOGGROUP "zypp::solver"
82 solver_set_flag( &satSolver_r, SOLVER_FLAG_FOCUS_INSTALLED, 0 );
83 solver_set_flag( &satSolver_r, SOLVER_FLAG_FOCUS_BEST, 0 );
86 solver_set_flag( &satSolver_r, SOLVER_FLAG_FOCUS_INSTALLED, 1 );
87 solver_set_flag( &satSolver_r, SOLVER_FLAG_FOCUS_BEST, 0 );
90 solver_set_flag( &satSolver_r, SOLVER_FLAG_FOCUS_INSTALLED, 0 );
91 solver_set_flag( &satSolver_r, SOLVER_FLAG_FOCUS_BEST, 1 );
99 inline sat::Queue collectPseudoInstalled(
const ResPool & pool_r )
102 for (
const PoolItem & pi : pool_r )
110 inline void solverCopyBackWeak(
sat::detail::CSolver & satSolver_r, PoolItemList & orphanedItems_r )
114 sat::Queue recommendations;
115 sat::Queue suggestions;
116 ::solver_get_recommendations( &satSolver_r, recommendations, suggestions, 0 );
118 PoolItem(sat::Solvable(recommendations[i])).status().setRecommended(
true );
120 PoolItem(sat::Solvable(suggestions[i])).status().setSuggested(
true );
123 orphanedItems_r.clear();
125 ::solver_get_orphaned( &satSolver_r, orphaned );
128 PoolItem pi { sat::Solvable(orphaned[i]) };
129 pi.status().setOrphaned(
true );
130 orphanedItems_r.push_back( pi );
135 ::solver_get_unneeded( &satSolver_r, unneeded, 1 );
137 PoolItem(sat::Solvable(unneeded[i])).status().setUnneeded(
true );
142 inline void solverCopyBackValidate(
sat::detail::CSolver & satSolver_r,
const ResPool & pool_r )
144 sat::Queue pseudoItems { collectPseudoInstalled( pool_r ) };
145 if ( ! pseudoItems.empty() )
147 sat::Queue pseudoFlags;
148 ::solver_trivial_installable( &satSolver_r, pseudoItems, pseudoFlags );
152 PoolItem pi { sat::Solvable(pseudoItems[i]) };
153 switch ( pseudoFlags[i] )
155 case 0: pi.status().setBroken();
break;
156 case 1: pi.status().setSatisfied();
break;
157 case -1: pi.status().setNonRelevant();
break;
158 default: pi.status().setUndetermined();
break;
171 #define MAYBE_CLEANDEPS (cleandepsOnRemove()?SOLVER_CLEANDEPS:0)
190 if ( ! pseudoItems_r.
empty() )
192 MIL <<
"Establish..." << endl;
194 ::pool_set_custom_vendorcheck( cPool, &
vendorCheck );
200 jobQueue.
push( SOLVER_NOOBSOLETES | SOLVER_SOLVABLE );
201 jobQueue.
push( solv.id() );
206 if ( ::solver_solve( cSolver, jobQueue ) != 0 )
207 INT <<
"How can establish fail?" << endl;
209 ::solver_trivial_installable( cSolver, pseudoItems_r, pseudoFlags_r );
214 switch ( pseudoFlags_r[i] )
216 case 0: pi.status().setBroken();
break;
217 case 1: pi.status().setSatisfied();
break;
218 case -1: pi.status().setNonRelevant();
break;
219 default: pi.status().setUndetermined();
break;
222 MIL <<
"Establish DONE" << endl;
225 MIL <<
"Establish not needed." << endl;
231 return std::string();
249 os <<
"<resolver>" << endl;
251 #define OUTS(X) os << " " << #X << "\t= " << solver_get_flag(_satSolver, SOLVER_FLAG_##X) << endl
252 OUTS( ALLOW_DOWNGRADE );
253 OUTS( ALLOW_ARCHCHANGE );
254 OUTS( ALLOW_VENDORCHANGE );
255 OUTS( ALLOW_NAMECHANGE );
256 OUTS( ALLOW_UNINSTALL );
257 OUTS( NO_UPDATEPROVIDE );
258 OUTS( SPLITPROVIDES );
259 OUTS( IGNORE_RECOMMENDED );
260 OUTS( ADD_ALREADY_RECOMMENDED );
261 OUTS( NO_INFARCHCHECK );
262 OUTS( KEEP_EXPLICIT_OBSOLETES );
263 OUTS( BEST_OBEY_POLICY );
264 OUTS( NO_AUTOTARGET );
265 OUTS( DUP_ALLOW_DOWNGRADE );
266 OUTS( DUP_ALLOW_ARCHCHANGE );
267 OUTS( DUP_ALLOW_VENDORCHANGE );
268 OUTS( DUP_ALLOW_NAMECHANGE );
269 OUTS( KEEP_ORPHANS );
270 OUTS( BREAK_ORPHANS );
271 OUTS( YUM_OBSOLETES );
273 os <<
" focus = " << _focus << endl;
274 os <<
" distupgrade = " << _distupgrade << endl;
275 os <<
" distupgrade_removeunsupported = " << _distupgrade_removeunsupported << endl;
276 os <<
" solveSrcPackages = " << _solveSrcPackages << endl;
277 os <<
" cleandepsOnRemove = " << _cleandepsOnRemove << endl;
278 os <<
" fixsystem = " << _fixsystem << endl;
282 return os <<
"<resolver/>" << endl;
292 , _focus ( ZConfig::instance().solver_focus() )
294 , _allowdowngrade ( false )
295 , _allownamechange ( true )
296 , _allowarchchange ( false )
298 , _allowuninstall ( false )
299 , _updatesystem(false)
300 , _noupdateprovide ( false )
301 , _dosplitprovides ( true )
302 , _onlyRequires (ZConfig::instance().solver_onlyRequires())
303 , _ignorealreadyrecommended(true)
304 , _distupgrade(false)
305 , _distupgrade_removeunsupported(false)
310 , _solveSrcPackages(false)
311 , _cleandepsOnRemove(ZConfig::instance().solver_cleandepsOnRemove())
316 SATResolver::~SATResolver()
324 SATResolver::pool (
void)
const
346 XDEBUG(
"SATSolutionToPool install returns " << item <<
", " << r);
350 XDEBUG(
"SATSolutionToPool upgrade returns " << item <<
", " << r);
354 XDEBUG(
"SATSolutionToPool remove returns " << item <<
", " << r);
375 PoolItemList & items_to_remove_r,
376 PoolItemList & items_to_lock_r,
377 PoolItemList & items_to_keep_r,
378 bool solveSrcPackages_r )
379 : _items_to_install( items_to_install_r )
380 , _items_to_remove( items_to_remove_r )
381 , _items_to_lock( items_to_lock_r )
382 , _items_to_keep( items_to_keep_r )
383 , _solveSrcPackages( solveSrcPackages_r )
385 _items_to_install.clear();
386 _items_to_remove.clear();
387 _items_to_lock.clear();
388 _items_to_keep.clear();
413 itemStatus.
isUninstalled() ? _items_to_install.push_back( item_r )
414 : _items_to_remove.push_back( item_r );
break;
446 : is_updated( false )
447 , _installed( installed_r )
472 queue_push( &(_jobQueue), SOLVER_VERIFY|SOLVER_SOLVABLE_ALL);
473 queue_push( &(_jobQueue), 0 );
476 queue_push( &(_jobQueue), SOLVER_UPDATE|SOLVER_SOLVABLE_ALL);
477 queue_push( &(_jobQueue), 0 );
480 queue_push( &(_jobQueue), SOLVER_DISTUPGRADE|SOLVER_SOLVABLE_ALL);
481 queue_push( &(_jobQueue), 0 );
483 if (_distupgrade_removeunsupported) {
484 queue_push( &(_jobQueue), SOLVER_DROP_ORPHANED|SOLVER_SOLVABLE_ALL);
485 queue_push( &(_jobQueue), 0 );
487 solverSetFocus( *_satSolver, _focus );
488 solver_set_flag(_satSolver, SOLVER_FLAG_ADD_ALREADY_RECOMMENDED, !_ignorealreadyrecommended);
489 solver_set_flag(_satSolver, SOLVER_FLAG_ALLOW_DOWNGRADE, _allowdowngrade);
490 solver_set_flag(_satSolver, SOLVER_FLAG_ALLOW_NAMECHANGE, _allownamechange);
491 solver_set_flag(_satSolver, SOLVER_FLAG_ALLOW_ARCHCHANGE, _allowarchchange);
493 solver_set_flag(_satSolver, SOLVER_FLAG_ALLOW_UNINSTALL, _allowuninstall);
494 solver_set_flag(_satSolver, SOLVER_FLAG_NO_UPDATEPROVIDE, _noupdateprovide);
495 solver_set_flag(_satSolver, SOLVER_FLAG_SPLITPROVIDES, _dosplitprovides);
496 solver_set_flag(_satSolver, SOLVER_FLAG_IGNORE_RECOMMENDED,
false);
497 solver_set_flag(_satSolver, SOLVER_FLAG_ONLY_NAMESPACE_RECOMMENDED, _onlyRequires);
506 MIL <<
"Starting solving...." << endl;
508 if ( solver_solve( _satSolver, &(_jobQueue) ) == 0 )
515 if ( _distupgrade_removeunsupported )
516 MIL <<
"Droplist processing not needed. RemoveUnsupported is On." << endl;
518 MIL <<
"Droplist processing is disabled in ZConfig." << endl;
521 bool resolve =
false;
522 MIL <<
"Checking droplists ..." << endl;
525 solver_get_decisionqueue( _satSolver, decisionq );
532 static const Capability productCap {
"product()" };
533 if ( slv && slv.provides().matches( productCap ) )
535 CapabilitySet droplist { slv.valuesOfNamespace(
"weakremover" ) };
536 MIL <<
"Droplist for " << slv <<
": size " << droplist.size() << endl;
537 if ( !droplist.empty() )
539 for (
const auto & cap : droplist )
541 queue_push( &_jobQueue, SOLVER_DROP_ORPHANED | SOLVER_SOLVABLE_NAME );
542 queue_push( &_jobQueue, cap.id() );
545 queue_push( &(_jobQueue), SOLVER_INSTALL | SOLVER_SOLVABLE );
546 queue_push( &(_jobQueue),
id );
552 solver_solve( _satSolver, &(_jobQueue) );
556 MIL <<
"....Solver end" << endl;
560 _result_items_to_install.clear();
561 _result_items_to_remove.clear();
565 queue_init(&decisionq);
566 solver_get_decisionqueue(_satSolver, &decisionq);
567 for (
int i = 0; i < decisionq.count; ++i )
569 Id p = decisionq.elements[i];
574 if ( ! slv || slv.isSystem() )
577 PoolItem poolItem( slv );
579 _result_items_to_install.push_back( poolItem );
581 queue_free(&decisionq);
585 if ( systemRepo && ! systemRepo.solvablesEmpty() )
587 bool mustCheckObsoletes =
false;
588 for_( it, systemRepo.solvablesBegin(), systemRepo.solvablesEnd() )
590 if (solver_get_decisionlevel(_satSolver, it->id()) > 0)
594 CheckIfUpdate info( *it );
595 PoolItem poolItem( *it );
597 _pool.byIdentEnd( poolItem ),
598 resfilter::ByUninstalled(),
599 functor::functorRef<bool,PoolItem> (info) );
601 if (info.is_updated) {
605 if ( ! mustCheckObsoletes )
606 mustCheckObsoletes =
true;
608 _result_items_to_remove.push_back (poolItem);
610 if ( mustCheckObsoletes )
612 sat::WhatObsoletes obsoleted( _result_items_to_install.begin(), _result_items_to_install.end() );
613 for_( it, obsoleted.poolItemBegin(), obsoleted.poolItemEnd() )
615 ResStatus & status( it->status() );
617 if ( status.transacts() && ! status.isToBeUninstalledDueToUpgrade() )
618 status.setToBeUninstalledDueToObsolete();
625 solverCopyBackWeak( *_satSolver, _problem_items );
626 solverCopyBackValidate( *_satSolver, _pool );
631 for (CapabilitySet::const_iterator iter = requires_caps.begin(); iter != requires_caps.end(); iter++) {
632 sat::WhatProvides rpmProviders(*iter);
633 for_( iter2, rpmProviders.begin(), rpmProviders.end() ) {
634 PoolItem poolItem(*iter2);
635 if (poolItem.status().isToBeInstalled()) {
636 MIL <<
"User requirement " << *iter <<
" sets " << poolItem << endl;
641 for (CapabilitySet::const_iterator iter = conflict_caps.begin(); iter != conflict_caps.end(); iter++) {
642 sat::WhatProvides rpmProviders(*iter);
643 for_( iter2, rpmProviders.begin(), rpmProviders.end() ) {
644 PoolItem poolItem(*iter2);
645 if (poolItem.status().isToBeUninstalled()) {
646 MIL <<
"User conflict " << *iter <<
" sets " << poolItem << endl;
652 if (solver_problem_count(_satSolver) > 0 )
654 ERR <<
"Solverrun finished with an ERROR" << endl;
663 SATResolver::solverInit(
const PoolItemList & weakItems)
666 MIL <<
"SATResolver::solverInit()" << endl;
670 _satSolver = solver_create( _satPool );
674 bool toRelax =
false;
675 if ( _distupgrade ) {
676 for ( sat::Solvable solv : sat::WhatProvides( Capability(
"dup-vendor-relax(suse)") ) ) {
677 if ( ! solv.isSystem() ) {
678 MIL <<
"Relaxed vendor check requested by " << solv << endl;
687 queue_init( &_jobQueue );
691 SATCollectTransact collector( _items_to_install, _items_to_remove, _items_to_lock, _items_to_keep, solveSrcPackages() );
692 invokeOnEach ( _pool.begin(), _pool.end(), functor::functorRef<bool,PoolItem>( collector ) );
695 for (PoolItemList::const_iterator iter = weakItems.begin(); iter != weakItems.end(); iter++) {
696 Id
id = (*iter)->satSolvable().id();
698 ERR <<
"Weaken: " << *iter <<
" not found" << endl;
700 MIL <<
"Weaken dependencies of " << *iter << endl;
701 queue_push( &(_jobQueue), SOLVER_WEAKENDEPS | SOLVER_SOLVABLE );
702 queue_push( &(_jobQueue),
id );
707 queue_push( &(_jobQueue), SOLVER_BLACKLIST|SOLVER_SOLVABLE_PROVIDES );
709 queue_push( &(_jobQueue), SOLVER_BLACKLIST|SOLVER_SOLVABLE_PROVIDES );
715 const auto & trackedLocaleIds( myPool().trackedLocaleIds() );
718 for (
const auto & locale : trackedLocaleIds.added() )
720 queue_push( &(_jobQueue), SOLVER_INSTALL | SOLVER_SOLVABLE_PROVIDES );
724 for (
const auto & locale : trackedLocaleIds.removed() )
726 queue_push( &(_jobQueue), SOLVER_ERASE | SOLVER_SOLVABLE_PROVIDES | SOLVER_CLEANDEPS );
732 for (
const sat::Solvable & solv : myPool().multiversionList() )
734 queue_push( &(_jobQueue), SOLVER_NOOBSOLETES | SOLVER_SOLVABLE );
735 queue_push( &(_jobQueue), solv.id() );
738 ::pool_add_userinstalled_jobs(_satPool,
sat::Pool::instance().autoInstalled(), &(_jobQueue), GET_USERINSTALLED_NAMES|GET_USERINSTALLED_INVERTED);
742 SATResolver::solverEnd()
747 solver_free(_satSolver);
749 queue_free( &(_jobQueue) );
755 SATResolver::resolvePool(
const CapabilitySet & requires_caps,
757 const PoolItemList & weakItems,
758 const std::set<Repository> & upgradeRepos)
760 MIL <<
"SATResolver::resolvePool()" << endl;
763 solverInit(weakItems);
765 for (PoolItemList::const_iterator iter = _items_to_install.begin(); iter != _items_to_install.end(); iter++) {
766 Id
id = (*iter)->satSolvable().id();
768 ERR <<
"Install: " << *iter <<
" not found" << endl;
770 MIL <<
"Install " << *iter << endl;
771 queue_push( &(_jobQueue), SOLVER_INSTALL | SOLVER_SOLVABLE );
772 queue_push( &(_jobQueue),
id );
776 for (PoolItemList::const_iterator iter = _items_to_remove.begin(); iter != _items_to_remove.end(); iter++) {
777 Id
id = (*iter)->satSolvable().id();
779 ERR <<
"Delete: " << *iter <<
" not found" << endl;
781 MIL <<
"Delete " << *iter << endl;
782 queue_push( &(_jobQueue), SOLVER_ERASE | SOLVER_SOLVABLE |
MAYBE_CLEANDEPS );
783 queue_push( &(_jobQueue),
id);
787 for_( iter, upgradeRepos.begin(), upgradeRepos.end() )
789 queue_push( &(_jobQueue), SOLVER_DISTUPGRADE | SOLVER_SOLVABLE_REPO );
790 queue_push( &(_jobQueue), iter->get()->repoid );
791 MIL <<
"Upgrade repo " << *iter << endl;
794 for (CapabilitySet::const_iterator iter = requires_caps.begin(); iter != requires_caps.end(); iter++) {
795 queue_push( &(_jobQueue), SOLVER_INSTALL | SOLVER_SOLVABLE_PROVIDES );
796 queue_push( &(_jobQueue), iter->id() );
797 MIL <<
"Requires " << *iter << endl;
800 for (CapabilitySet::const_iterator iter = conflict_caps.begin(); iter != conflict_caps.end(); iter++) {
801 queue_push( &(_jobQueue), SOLVER_ERASE | SOLVER_SOLVABLE_PROVIDES |
MAYBE_CLEANDEPS );
802 queue_push( &(_jobQueue), iter->id() );
803 MIL <<
"Conflicts " << *iter << endl;
807 setSystemRequirements();
813 bool ret = solving(requires_caps, conflict_caps);
815 (ret?
MIL:
WAR) <<
"SATResolver::resolvePool() done. Ret:" << ret << endl;
822 const PoolItemList & weakItems)
824 MIL <<
"SATResolver::resolvQueue()" << endl;
827 solverInit(weakItems);
830 for (SolverQueueItemList::const_iterator iter = requestQueue.begin(); iter != requestQueue.end(); iter++) {
831 (*iter)->addRule(_jobQueue);
835 for (PoolItemList::const_iterator iter = _items_to_install.begin(); iter != _items_to_install.end(); iter++) {
836 Id
id = (*iter)->satSolvable().id();
838 ERR <<
"Install: " << *iter <<
" not found" << endl;
840 MIL <<
"Install " << *iter << endl;
841 queue_push( &(_jobQueue), SOLVER_INSTALL | SOLVER_SOLVABLE );
842 queue_push( &(_jobQueue),
id );
845 for (PoolItemList::const_iterator iter = _items_to_remove.begin(); iter != _items_to_remove.end(); iter++) {
847 MIL <<
"Delete " << *iter << ident << endl;
848 queue_push( &(_jobQueue), SOLVER_ERASE | SOLVER_SOLVABLE_NAME |
MAYBE_CLEANDEPS );
849 queue_push( &(_jobQueue), ident);
853 setSystemRequirements();
859 bool ret = solving();
861 MIL <<
"SATResolver::resolveQueue() done. Ret:" << ret << endl;
866 void SATResolver::doUpdate()
868 MIL <<
"SATResolver::doUpdate()" << endl;
871 solverInit(PoolItemList());
874 setSystemRequirements();
880 queue_push( &(_jobQueue), SOLVER_VERIFY|SOLVER_SOLVABLE_ALL);
881 queue_push( &(_jobQueue), 0 );
884 queue_push( &(_jobQueue), SOLVER_UPDATE|SOLVER_SOLVABLE_ALL);
885 queue_push( &(_jobQueue), 0 );
888 queue_push( &(_jobQueue), SOLVER_DISTUPGRADE|SOLVER_SOLVABLE_ALL);
889 queue_push( &(_jobQueue), 0 );
891 if (_distupgrade_removeunsupported) {
892 queue_push( &(_jobQueue), SOLVER_DROP_ORPHANED|SOLVER_SOLVABLE_ALL);
893 queue_push( &(_jobQueue), 0 );
895 solverSetFocus( *_satSolver, _focus );
896 solver_set_flag(_satSolver, SOLVER_FLAG_ADD_ALREADY_RECOMMENDED, !_ignorealreadyrecommended);
897 solver_set_flag(_satSolver, SOLVER_FLAG_ALLOW_DOWNGRADE, _allowdowngrade);
898 solver_set_flag(_satSolver, SOLVER_FLAG_ALLOW_NAMECHANGE, _allownamechange);
899 solver_set_flag(_satSolver, SOLVER_FLAG_ALLOW_ARCHCHANGE, _allowarchchange);
901 solver_set_flag(_satSolver, SOLVER_FLAG_ALLOW_UNINSTALL, _allowuninstall);
902 solver_set_flag(_satSolver, SOLVER_FLAG_NO_UPDATEPROVIDE, _noupdateprovide);
903 solver_set_flag(_satSolver, SOLVER_FLAG_SPLITPROVIDES, _dosplitprovides);
904 solver_set_flag(_satSolver, SOLVER_FLAG_IGNORE_RECOMMENDED,
false);
905 solver_set_flag(_satSolver, SOLVER_FLAG_ONLY_NAMESPACE_RECOMMENDED, _onlyRequires);
910 MIL <<
"Starting solving for update...." << endl;
912 solver_solve( _satSolver, &(_jobQueue) );
913 MIL <<
"....Solver end" << endl;
920 queue_init(&decisionq);
921 solver_get_decisionqueue(_satSolver, &decisionq);
922 for (
int i = 0; i < decisionq.count; i++)
924 Id p = decisionq.elements[i];
929 if ( ! solv || solv.isSystem() )
934 queue_free(&decisionq);
937 if ( _satSolver->pool->installed ) {
938 for (
int i = _satSolver->pool->installed->start; i < _satSolver->pool->installed->start + _satSolver->pool->installed->nsolvables; i++)
940 if (solver_get_decisionlevel(_satSolver, i) > 0)
943 PoolItem poolItem( _pool.find( sat::Solvable(i) ) );
946 CheckIfUpdate info( (sat::Solvable(i)) );
948 _pool.byIdentEnd( poolItem ),
949 resfilter::ByUninstalled(),
950 functor::functorRef<bool,PoolItem> (info) );
952 if (info.is_updated) {
958 ERR <<
"id " << i <<
" not found in ZYPP pool." << endl;
965 solverCopyBackWeak( *_satSolver, _problem_items );
966 solverCopyBackValidate( *_satSolver, _pool );
968 MIL <<
"SATResolver::doUpdate() done" << endl;
988 : problemSolution (p)
995 problemSolution->addSingleAction (p, action);
1028 std::vector<std::string> SATResolver::SATgetCompleteProblemInfoStrings ( Id problem )
1030 std::vector<std::string> ret;
1031 sat::Queue problems;
1032 solver_findallproblemrules( _satSolver, problem, problems );
1038 SolverRuleinfo ruleClass = solver_ruleclass( _satSolver, problems[i]);
1039 if ( ruleClass != SolverRuleinfo::SOLVER_RULE_UPDATE && ruleClass != SolverRuleinfo::SOLVER_RULE_JOB ) {
1045 SolverRuleinfo ruleClass = solver_ruleclass( _satSolver, problems[i]);
1046 if ( nobad && ( ruleClass == SolverRuleinfo::SOLVER_RULE_UPDATE || ruleClass == SolverRuleinfo::SOLVER_RULE_JOB ) ) {
1052 std::string pInfo = SATproblemRuleInfoString( problems[i], detail, ignore );
1055 if ( std::find( ret.begin(), ret.end(), pInfo ) == ret.end() )
1056 ret.push_back( pInfo );
1061 std::string SATResolver::SATprobleminfoString(Id problem, std::string &detail, Id &ignoreId)
1065 Id probr = solver_findproblemrule(_satSolver, problem);
1066 return SATproblemRuleInfoString( probr, detail, ignoreId );
1069 #ifdef ZYPPNEWSPPSWENPPYZ
1070 #warning New texts in SP preview - still to be translated...
1071 std::string SATResolver::SATproblemRuleInfoString (Id probr, std::string &detail, Id &ignoreId)
1075 Id dep, source, target;
1076 SolverRuleinfo type = solver_ruleinfo(_satSolver, probr, &source, &target, &dep);
1080 sat::Solvable s = mapSolvable( source );
1081 sat::Solvable s2 = mapSolvable( target );
1088 case SOLVER_RULE_DISTUPGRADE:
1090 ret = str::Format(
_(
"the installed %1% does not belong to a distupgrade repository and must be replaced") ) % s.asString();
1092 ret = str::Format(
_(
"the to be installed %1% does not belong to a distupgrade repository") ) % s.asString();
1094 case SOLVER_RULE_INFARCH:
1096 ret = str::Format(
_(
"the installed %1% has inferior architecture") ) % s.asString();
1098 ret = str::Format(
_(
"the to be installed %1% has inferior architecture") ) % s.asString();
1100 case SOLVER_RULE_UPDATE:
1101 ret = str::Format(
_(
"problem with the installed %1%") ) % s.asString();
1103 case SOLVER_RULE_JOB:
1104 ret =
_(
"conflicting requests");
1106 case SOLVER_RULE_PKG:
1107 ret =
_(
"some dependency problem");
1109 case SOLVER_RULE_JOB_NOTHING_PROVIDES_DEP:
1110 ret = str::Format(
_(
"nothing provides the requested '%1%'") ) % pool_dep2str(pool, dep);
1111 detail +=
_(
"Have you enabled all the required repositories?");
1113 case SOLVER_RULE_JOB_UNKNOWN_PACKAGE:
1114 ret = str::Format(
_(
"the requested package %1% does not exist") ) % pool_dep2str(pool, dep);
1115 detail +=
_(
"Have you enabled all the required repositories?");
1117 case SOLVER_RULE_JOB_UNSUPPORTED:
1118 ret =
_(
"unsupported request");
1120 case SOLVER_RULE_JOB_PROVIDED_BY_SYSTEM:
1121 ret = str::Format(
_(
"'%1%' is provided by the system and cannot be erased") ) % pool_dep2str(pool, dep);
1123 case SOLVER_RULE_PKG_NOT_INSTALLABLE:
1124 ret = str::Format(
_(
"%1% is not installable") ) % s.asString();
1126 case SOLVER_RULE_PKG_NOTHING_PROVIDES_DEP:
1129 ret = str::Format(
_(
"nothing provides '%1%' needed by the installed %2%") ) % pool_dep2str(pool, dep) % s.asString();
1131 ret = str::Format(
_(
"nothing provides '%1%' needed by the to be installed %2%") ) % pool_dep2str(pool, dep) % s.asString();
1133 case SOLVER_RULE_PKG_SAME_NAME:
1134 ret = str::Format(
_(
"cannot install both %1% and %2%") ) % s.asString() % s2.asString();
1136 case SOLVER_RULE_PKG_CONFLICTS:
1137 if ( s.isSystem() ) {
1138 if ( s2.isSystem() )
1139 ret = str::Format(
_(
"the installed %1% conflicts with '%2%' provided by the installed %3%") ) % s.asString() % pool_dep2str(pool, dep) % s2.asString();
1141 ret = str::Format(
_(
"the installed %1% conflicts with '%2%' provided by the to be installed %3%") ) % s.asString() % pool_dep2str(pool, dep) % s2.asString();
1144 if ( s2.isSystem() )
1145 ret = str::Format(
_(
"the to be installed %1% conflicts with '%2%' provided by the installed %3%") ) % s.asString() % pool_dep2str(pool, dep) % s2.asString();
1147 ret = str::Format(
_(
"the to be installed %1% conflicts with '%2%' provided by the to be installed %3%") ) % s.asString() % pool_dep2str(pool, dep) % s2.asString();
1150 case SOLVER_RULE_PKG_OBSOLETES:
1151 case SOLVER_RULE_PKG_INSTALLED_OBSOLETES:
1152 if ( s.isSystem() ) {
1153 if ( s2.isSystem() )
1154 ret = str::Format(
_(
"the installed %1% obsoletes '%2%' provided by the installed %3%") ) % s.asString() % pool_dep2str(pool, dep) % s2.asString();
1156 ret = str::Format(
_(
"the installed %1% obsoletes '%2%' provided by the to be installed %3%") ) % s.asString() % pool_dep2str(pool, dep) % s2.asString();
1159 if ( s2.isSystem() )
1160 ret = str::Format(
_(
"the to be installed %1% obsoletes '%2%' provided by the installed %3%") ) % s.asString() % pool_dep2str(pool, dep) % s2.asString();
1162 ret = str::Format(
_(
"the to be installed %1% obsoletes '%2%' provided by the to be installed %3%") ) % s.asString() % pool_dep2str(pool, dep) % s2.asString();
1165 case SOLVER_RULE_PKG_SELF_CONFLICT:
1167 ret = str::Format(
_(
"the installed %1% conflicts with '%2%' provided by itself") ) % s.asString() % pool_dep2str(pool, dep);
1169 ret = str::Format(
_(
"the to be installed %1% conflicts with '%2%' provided by itself") ) % s.asString() % pool_dep2str(pool, dep);
1171 case SOLVER_RULE_PKG_REQUIRES: {
1173 Capability cap(dep);
1174 sat::WhatProvides possibleProviders(cap);
1177 typedef std::list<PoolItem> ProviderList;
1178 ProviderList providerlistInstalled, providerlistUninstalled;
1179 for_( iter1, possibleProviders.begin(), possibleProviders.end() ) {
1183 for_( iter2, possibleProviders.begin(), possibleProviders.end() ) {
1186 && ( (provider1.status().isInstalled() && provider2.status().isUninstalled())
1187 || (provider2.status().isInstalled() && provider1.status().isUninstalled()) )) {
1193 if (provider1.status().isInstalled())
1194 providerlistInstalled.push_back(provider1);
1196 providerlistUninstalled.push_back(provider1);
1201 ret = str::Format(
_(
"the installed %1% requires '%2%', but this requirement cannot be provided") ) % s.
asString() % pool_dep2str(pool, dep);
1203 ret = str::Format(
_(
"the to be installed %1% requires '%2%', but this requirement cannot be provided") ) % s.asString() % pool_dep2str(pool, dep);
1204 if (providerlistInstalled.size() > 0) {
1205 detail +=
_(
"deleted providers: ");
1206 for (ProviderList::const_iterator iter = providerlistInstalled.begin(); iter != providerlistInstalled.end(); iter++) {
1207 if (iter == providerlistInstalled.begin())
1213 if (providerlistUninstalled.size() > 0) {
1214 if (detail.size() > 0)
1215 detail +=
_(
"\nnot installable providers: ");
1217 detail =
_(
"not installable providers: ");
1218 for (ProviderList::const_iterator iter = providerlistUninstalled.begin(); iter != providerlistUninstalled.end(); iter++) {
1219 if (iter == providerlistUninstalled.begin())
1228 DBG <<
"Unknown rule type(" << type <<
") going to query libsolv for rule information." << endl;
1229 ret =
str::asString( ::solver_problemruleinfo2str( _satSolver, type,
static_cast<Id
>(s.id()),
static_cast<Id
>(s2.id()), dep ) );
1237 SATResolver::problems ()
1240 if (_satSolver && solver_problem_count(_satSolver)) {
1244 Id problem, solution, element;
1245 sat::Solvable s, sd;
1247 CapabilitySet system_requires = SystemCheck::instance().requiredSystemCap();
1248 CapabilitySet system_conflicts = SystemCheck::instance().conflictSystemCap();
1250 MIL <<
"Encountered problems! Here are the solutions:\n" << endl;
1253 while ((problem = solver_next_problem(_satSolver, problem)) != 0) {
1254 MIL <<
"Problem " << pcnt++ <<
":" << endl;
1255 MIL <<
"====================================" << endl;
1258 std::string whatString = SATprobleminfoString (problem,detail,ignoreId);
1259 MIL << whatString << endl;
1260 MIL <<
"------------------------------------" << endl;
1261 ResolverProblem_Ptr resolverProblem =
new ResolverProblem (whatString, detail, SATgetCompleteProblemInfoStrings( problem ));
1264 while ((solution = solver_next_solution(_satSolver, problem, solution)) != 0) {
1266 ProblemSolutionCombi *problemSolution =
new ProblemSolutionCombi;
1267 while ((element = solver_next_solutionelement(_satSolver, problem, solution, element, &p, &rp)) != 0) {
1268 if (p == SOLVER_SOLUTION_JOB) {
1270 what = _jobQueue.elements[rp];
1271 switch (_jobQueue.elements[rp-1]&(SOLVER_SELECTMASK|SOLVER_JOBMASK))
1273 case SOLVER_INSTALL | SOLVER_SOLVABLE: {
1274 s = mapSolvable (what);
1275 PoolItem poolItem = _pool.find (s);
1277 if (pool->installed && s.get()->repo == pool->installed) {
1278 problemSolution->addSingleAction (poolItem, REMOVE);
1279 std::string description = str::Format(
_(
"remove lock to allow removal of %1%") ) % s.asString();
1280 MIL << description << endl;
1281 problemSolution->addDescription (description);
1283 problemSolution->addSingleAction (poolItem, KEEP);
1284 std::string description = str::Format(
_(
"do not install %1%") ) % s.asString();
1285 MIL << description << endl;
1286 problemSolution->addDescription (description);
1289 ERR <<
"SOLVER_INSTALL_SOLVABLE: No item found for " << s.asString() << endl;
1293 case SOLVER_ERASE | SOLVER_SOLVABLE: {
1294 s = mapSolvable (what);
1295 PoolItem poolItem = _pool.find (s);
1297 if (pool->installed && s.get()->repo == pool->installed) {
1298 problemSolution->addSingleAction (poolItem, KEEP);
1299 std::string description = str::Format(
_(
"keep %1%") ) % s.asString();
1300 MIL << description << endl;
1301 problemSolution->addDescription (description);
1303 problemSolution->addSingleAction (poolItem, UNLOCK);
1304 std::string description = str::Format(
_(
"remove lock to allow installation of %1%") ) %
itemToString( poolItem );
1305 MIL << description << endl;
1306 problemSolution->addDescription (description);
1309 ERR <<
"SOLVER_ERASE_SOLVABLE: No item found for " << s.asString() << endl;
1313 case SOLVER_INSTALL | SOLVER_SOLVABLE_NAME:
1315 IdString ident( what );
1316 SolverQueueItemInstall_Ptr install =
1317 new SolverQueueItemInstall(_pool, ident.asString(),
false );
1318 problemSolution->addSingleAction (install, REMOVE_SOLVE_QUEUE_ITEM);
1320 std::string description = str::Format(
_(
"do not install %1%") ) % ident;
1321 MIL << description << endl;
1322 problemSolution->addDescription (description);
1325 case SOLVER_ERASE | SOLVER_SOLVABLE_NAME:
1329 IdString ident( what );
1330 FindPackage info (problemSolution, KEEP);
1332 _pool.byIdentEnd( ident ),
1334 resfilter::ByTransact ()),
1335 functor::functorRef<bool,PoolItem> (info) );
1337 SolverQueueItemDelete_Ptr del =
1338 new SolverQueueItemDelete(_pool, ident.asString(),
false );
1339 problemSolution->addSingleAction (del, REMOVE_SOLVE_QUEUE_ITEM);
1341 std::string description = str::Format(
_(
"keep %1%") ) % ident;
1342 MIL << description << endl;
1343 problemSolution->addDescription (description);
1346 case SOLVER_INSTALL | SOLVER_SOLVABLE_PROVIDES:
1348 problemSolution->addSingleAction (Capability(what), REMOVE_EXTRA_REQUIRE);
1349 std::string description =
"";
1352 if (system_requires.find(Capability(what)) != system_requires.end()) {
1354 resolverProblem->setDetails( resolverProblem->description() +
"\n" + resolverProblem->details() );
1355 resolverProblem->setDescription(
_(
"This request will break your system!"));
1356 description =
_(
"ignore the warning of a broken system");
1357 description += std::string(
" (requires:")+pool_dep2str(pool, what)+
")";
1358 MIL << description << endl;
1359 problemSolution->addFrontDescription (description);
1361 description = str::Format(
_(
"do not ask to install a solvable providing %1%") ) % pool_dep2str(pool, what);
1362 MIL << description << endl;
1363 problemSolution->addDescription (description);
1367 case SOLVER_ERASE | SOLVER_SOLVABLE_PROVIDES:
1369 problemSolution->addSingleAction (Capability(what), REMOVE_EXTRA_CONFLICT);
1370 std::string description =
"";
1373 if (system_conflicts.find(Capability(what)) != system_conflicts.end()) {
1375 resolverProblem->setDetails( resolverProblem->description() +
"\n" + resolverProblem->details() );
1376 resolverProblem->setDescription(
_(
"This request will break your system!"));
1377 description =
_(
"ignore the warning of a broken system");
1378 description += std::string(
" (conflicts:")+pool_dep2str(pool, what)+
")";
1379 MIL << description << endl;
1380 problemSolution->addFrontDescription (description);
1383 description = str::Format(
_(
"do not ask to delete all solvables providing %1%") ) % pool_dep2str(pool, what);
1384 MIL << description << endl;
1385 problemSolution->addDescription (description);
1389 case SOLVER_UPDATE | SOLVER_SOLVABLE:
1391 s = mapSolvable (what);
1392 PoolItem poolItem = _pool.find (s);
1394 if (pool->installed && s.get()->repo == pool->installed) {
1395 problemSolution->addSingleAction (poolItem, KEEP);
1396 std::string description = str::Format(
_(
"do not install most recent version of %1%") ) % s.asString();
1397 MIL << description << endl;
1398 problemSolution->addDescription (description);
1400 ERR <<
"SOLVER_INSTALL_SOLVABLE_UPDATE " << poolItem <<
" is not selected for installation" << endl;
1403 ERR <<
"SOLVER_INSTALL_SOLVABLE_UPDATE: No item found for " << s.asString() << endl;
1408 MIL <<
"- do something different" << endl;
1409 ERR <<
"No valid solution available" << endl;
1412 }
else if (p == SOLVER_SOLUTION_INFARCH) {
1413 s = mapSolvable (rp);
1414 PoolItem poolItem = _pool.find (s);
1415 if (pool->installed && s.get()->repo == pool->installed) {
1416 problemSolution->addSingleAction (poolItem, LOCK);
1417 std::string description = str::Format(
_(
"keep %1% despite the inferior architecture") ) % s.asString();
1418 MIL << description << endl;
1419 problemSolution->addDescription (description);
1421 problemSolution->addSingleAction (poolItem, INSTALL);
1422 std::string description = str::Format(
_(
"install %1% despite the inferior architecture") ) % s.asString();
1423 MIL << description << endl;
1424 problemSolution->addDescription (description);
1426 }
else if (p == SOLVER_SOLUTION_DISTUPGRADE) {
1427 s = mapSolvable (rp);
1428 PoolItem poolItem = _pool.find (s);
1429 if (pool->installed && s.get()->repo == pool->installed) {
1430 problemSolution->addSingleAction (poolItem, LOCK);
1431 std::string description = str::Format(
_(
"keep obsolete %1%") ) % s.asString();
1432 MIL << description << endl;
1433 problemSolution->addDescription (description);
1435 problemSolution->addSingleAction (poolItem, INSTALL);
1436 std::string description = str::Format(
_(
"install %1% from excluded repository") ) % s.asString();
1437 MIL << description << endl;
1438 problemSolution->addDescription (description);
1440 }
else if ( p == SOLVER_SOLUTION_BLACK ) {
1443 s = mapSolvable (rp);
1444 PoolItem poolItem = _pool.find (s);
1446 problemSolution->addSingleAction (poolItem, INSTALL);
1447 std::string description;
1448 if ( s.isRetracted() ) {
1450 description = str::Format(
_(
"install %1% although it has been retracted")) % s.asString();
1451 }
else if ( s.isPtf() ) {
1453 description = str::Format(
_(
"allow to install the PTF %1%")) % s.asString();
1456 description = str::Format(
_(
"install %1% although it is blacklisted")) % s.asString();
1458 MIL << description << endl;
1459 problemSolution->addDescription( description );
1460 }
else if ( p > 0 ) {
1462 s = mapSolvable (p);
1463 PoolItem itemFrom = _pool.find (s);
1468 sd = mapSolvable (rp);
1469 PoolItem itemTo = _pool.find (sd);
1470 if (itemFrom && itemTo) {
1471 problemSolution->addSingleAction (itemTo, INSTALL);
1472 int illegal = policy_is_illegal(_satSolver, s.get(), sd.get(), 0);
1474 if ((illegal & POLICY_ILLEGAL_DOWNGRADE) != 0)
1476 std::string description = str::Format(
_(
"downgrade of %1% to %2%") ) % s.asString() % sd.asString();
1477 MIL << description << endl;
1478 problemSolution->addDescription (description);
1481 if ((illegal & POLICY_ILLEGAL_ARCHCHANGE) != 0)
1483 std::string description = str::Format(
_(
"architecture change of %1% to %2%") ) % s.asString() % sd.asString();
1484 MIL << description << endl;
1485 problemSolution->addDescription (description);
1488 if ((illegal & POLICY_ILLEGAL_VENDORCHANGE) != 0)
1490 IdString s_vendor( s.vendor() );
1491 IdString sd_vendor( sd.vendor() );
1492 std::string description = str::Format(
_(
"install %1% (with vendor change)\n %2% --> %3%") ) % sd.asString() % ( s_vendor ? s_vendor.c_str() :
" (no vendor) " ) % ( sd_vendor ? sd_vendor.c_str() :
" (no vendor) " );
1493 MIL << description << endl;
1494 problemSolution->addDescription (description);
1498 std::string description = str::Format(
_(
"replacement of %1% with %2%") ) % s.asString() % sd.asString();
1499 MIL << description << endl;
1500 problemSolution->addDescription (description);
1503 ERR << s.asString() <<
" or " << sd.asString() <<
" not found" << endl;
1509 std::string description = str::Format(
_(
"deinstallation of %1%") ) % s.asString();
1510 MIL << description << endl;
1511 problemSolution->addDescription (description);
1512 problemSolution->addSingleAction (itemFrom, REMOVE);
1518 INT <<
"Unknown solution " << p << endl;
1522 resolverProblem->addSolution (problemSolution,
1523 problemSolution->actionCount() > 1 ?
true :
false);
1524 MIL <<
"------------------------------------" << endl;
1529 PoolItem item = _pool.find (sat::Solvable(ignoreId));
1530 ProblemSolutionIgnore *problemSolution =
new ProblemSolutionIgnore(item);
1531 resolverProblem->addSolution (problemSolution,
1533 MIL <<
"ignore some dependencies of " << item << endl;
1534 MIL <<
"------------------------------------" << endl;
1538 resolverProblems.push_back (resolverProblem);
1541 return resolverProblems;
1544 #warning Legacy texts
1545 std::string SATResolver::SATproblemRuleInfoString (Id probr, std::string &detail, Id &ignoreId)
1549 Id dep, source, target;
1550 SolverRuleinfo type = solver_ruleinfo(_satSolver, probr, &source, &target, &dep);
1554 sat::Solvable s = mapSolvable( source );
1555 sat::Solvable s2 = mapSolvable( target );
1562 case SOLVER_RULE_DISTUPGRADE:
1563 ret =
str::form (
_(
"%s does not belong to a distupgrade repository"), s.asString().c_str());
1565 case SOLVER_RULE_INFARCH:
1566 ret =
str::form (
_(
"%s has inferior architecture"), s.asString().c_str());
1568 case SOLVER_RULE_UPDATE:
1569 ret =
str::form (
_(
"problem with installed package %s"), s.asString().c_str());
1571 case SOLVER_RULE_JOB:
1572 ret =
_(
"conflicting requests");
1574 case SOLVER_RULE_PKG:
1575 ret =
_(
"some dependency problem");
1577 case SOLVER_RULE_JOB_NOTHING_PROVIDES_DEP:
1578 ret =
str::form (
_(
"nothing provides requested %s"), pool_dep2str(pool, dep));
1579 detail +=
_(
"Have you enabled all requested repositories?");
1581 case SOLVER_RULE_JOB_UNKNOWN_PACKAGE:
1582 ret =
str::form (
_(
"package %s does not exist"), pool_dep2str(pool, dep));
1583 detail +=
_(
"Have you enabled all requested repositories?");
1585 case SOLVER_RULE_JOB_UNSUPPORTED:
1586 ret =
_(
"unsupported request");
1588 case SOLVER_RULE_JOB_PROVIDED_BY_SYSTEM:
1589 ret =
str::form (
_(
"%s is provided by the system and cannot be erased"), pool_dep2str(pool, dep));
1591 case SOLVER_RULE_PKG_NOT_INSTALLABLE:
1592 ret =
str::form (
_(
"%s is not installable"), s.asString().c_str());
1594 case SOLVER_RULE_PKG_NOTHING_PROVIDES_DEP:
1596 ret =
str::form (
_(
"nothing provides %s needed by %s"), pool_dep2str(pool, dep), s.asString().c_str());
1598 case SOLVER_RULE_PKG_SAME_NAME:
1599 ret =
str::form (
_(
"cannot install both %s and %s"), s.asString().c_str(), s2.asString().c_str());
1601 case SOLVER_RULE_PKG_CONFLICTS:
1602 ret =
str::form (
_(
"%s conflicts with %s provided by %s"), s.asString().c_str(), pool_dep2str(pool, dep), s2.asString().c_str());
1604 case SOLVER_RULE_PKG_OBSOLETES:
1605 ret =
str::form (
_(
"%s obsoletes %s provided by %s"), s.asString().c_str(), pool_dep2str(pool, dep), s2.asString().c_str());
1607 case SOLVER_RULE_PKG_INSTALLED_OBSOLETES:
1608 ret =
str::form (
_(
"installed %s obsoletes %s provided by %s"), s.asString().c_str(), pool_dep2str(pool, dep), s2.asString().c_str());
1610 case SOLVER_RULE_PKG_SELF_CONFLICT:
1611 ret =
str::form (
_(
"solvable %s conflicts with %s provided by itself"), s.asString().c_str(), pool_dep2str(pool, dep));
1613 case SOLVER_RULE_PKG_REQUIRES: {
1615 Capability cap(dep);
1616 sat::WhatProvides possibleProviders(cap);
1619 typedef std::list<PoolItem> ProviderList;
1620 ProviderList providerlistInstalled, providerlistUninstalled;
1621 for_( iter1, possibleProviders.begin(), possibleProviders.end() ) {
1625 for_( iter2, possibleProviders.begin(), possibleProviders.end() ) {
1628 && ( (provider1.status().isInstalled() && provider2.status().isUninstalled())
1629 || (provider2.status().isInstalled() && provider1.status().isUninstalled()) )) {
1635 if (provider1.status().isInstalled())
1636 providerlistInstalled.push_back(provider1);
1638 providerlistUninstalled.push_back(provider1);
1642 ret =
str::form (
_(
"%s requires %s, but this requirement cannot be provided"), s.asString().c_str(), pool_dep2str(pool, dep));
1643 if (providerlistInstalled.size() > 0) {
1644 detail +=
_(
"deleted providers: ");
1645 for (ProviderList::const_iterator iter = providerlistInstalled.begin(); iter != providerlistInstalled.end(); iter++) {
1646 if (iter == providerlistInstalled.begin())
1652 if (providerlistUninstalled.size() > 0) {
1653 if (detail.size() > 0)
1654 detail +=
_(
"\nnot installable providers: ");
1656 detail =
_(
"not installable providers: ");
1657 for (ProviderList::const_iterator iter = providerlistUninstalled.begin(); iter != providerlistUninstalled.end(); iter++) {
1658 if (iter == providerlistUninstalled.begin())
1667 DBG <<
"Unknown rule type(" << type <<
") going to query libsolv for rule information." << endl;
1668 ret =
str::asString( ::solver_problemruleinfo2str( _satSolver, type,
static_cast<Id
>(s.id()),
static_cast<Id
>(s2.id()), dep ) );
1676 SATResolver::problems ()
1679 if (_satSolver && solver_problem_count(_satSolver)) {
1683 Id problem, solution, element;
1684 sat::Solvable s, sd;
1686 CapabilitySet system_requires = SystemCheck::instance().requiredSystemCap();
1687 CapabilitySet system_conflicts = SystemCheck::instance().conflictSystemCap();
1689 MIL <<
"Encountered problems! Here are the solutions:\n" << endl;
1692 while ((problem = solver_next_problem(_satSolver, problem)) != 0) {
1693 MIL <<
"Problem " << pcnt++ <<
":" << endl;
1694 MIL <<
"====================================" << endl;
1697 std::string whatString = SATprobleminfoString (problem,detail,ignoreId);
1698 MIL << whatString << endl;
1699 MIL <<
"------------------------------------" << endl;
1700 ResolverProblem_Ptr resolverProblem =
new ResolverProblem (whatString, detail, SATgetCompleteProblemInfoStrings( problem ));
1703 while ((solution = solver_next_solution(_satSolver, problem, solution)) != 0) {
1705 ProblemSolutionCombi *problemSolution =
new ProblemSolutionCombi;
1706 while ((element = solver_next_solutionelement(_satSolver, problem, solution, element, &p, &rp)) != 0) {
1707 if (p == SOLVER_SOLUTION_JOB) {
1709 what = _jobQueue.elements[rp];
1710 switch (_jobQueue.elements[rp-1]&(SOLVER_SELECTMASK|SOLVER_JOBMASK))
1712 case SOLVER_INSTALL | SOLVER_SOLVABLE: {
1713 s = mapSolvable (what);
1714 PoolItem poolItem = _pool.find (s);
1716 if (pool->installed && s.get()->repo == pool->installed) {
1717 problemSolution->addSingleAction (poolItem, REMOVE);
1718 std::string description =
str::form (
_(
"remove lock to allow removal of %s"), s.asString().c_str() );
1719 MIL << description << endl;
1720 problemSolution->addDescription (description);
1722 problemSolution->addSingleAction (poolItem, KEEP);
1723 std::string description =
str::form (
_(
"do not install %s"), s.asString().c_str());
1724 MIL << description << endl;
1725 problemSolution->addDescription (description);
1728 ERR <<
"SOLVER_INSTALL_SOLVABLE: No item found for " << s.asString() << endl;
1732 case SOLVER_ERASE | SOLVER_SOLVABLE: {
1733 s = mapSolvable (what);
1734 PoolItem poolItem = _pool.find (s);
1736 if (pool->installed && s.get()->repo == pool->installed) {
1737 problemSolution->addSingleAction (poolItem, KEEP);
1738 std::string description =
str::form (
_(
"keep %s"), s.asString().c_str());
1739 MIL << description << endl;
1740 problemSolution->addDescription (description);
1742 problemSolution->addSingleAction (poolItem, UNLOCK);
1743 std::string description =
str::form (
_(
"remove lock to allow installation of %s"),
itemToString( poolItem ).c_str());
1744 MIL << description << endl;
1745 problemSolution->addDescription (description);
1748 ERR <<
"SOLVER_ERASE_SOLVABLE: No item found for " << s.asString() << endl;
1752 case SOLVER_INSTALL | SOLVER_SOLVABLE_NAME:
1754 IdString ident( what );
1755 SolverQueueItemInstall_Ptr install =
1756 new SolverQueueItemInstall(_pool, ident.asString(),
false );
1757 problemSolution->addSingleAction (install, REMOVE_SOLVE_QUEUE_ITEM);
1759 std::string description =
str::form (
_(
"do not install %s"), ident.c_str() );
1760 MIL << description << endl;
1761 problemSolution->addDescription (description);
1764 case SOLVER_ERASE | SOLVER_SOLVABLE_NAME:
1768 IdString ident( what );
1769 FindPackage info (problemSolution, KEEP);
1771 _pool.byIdentEnd( ident ),
1773 resfilter::ByTransact ()),
1774 functor::functorRef<bool,PoolItem> (info) );
1776 SolverQueueItemDelete_Ptr del =
1777 new SolverQueueItemDelete(_pool, ident.asString(),
false );
1778 problemSolution->addSingleAction (del, REMOVE_SOLVE_QUEUE_ITEM);
1780 std::string description =
str::form (
_(
"keep %s"), ident.c_str());
1781 MIL << description << endl;
1782 problemSolution->addDescription (description);
1785 case SOLVER_INSTALL | SOLVER_SOLVABLE_PROVIDES:
1787 problemSolution->addSingleAction (Capability(what), REMOVE_EXTRA_REQUIRE);
1788 std::string description =
"";
1791 if (system_requires.find(Capability(what)) != system_requires.end()) {
1793 resolverProblem->setDetails( resolverProblem->description() +
"\n" + resolverProblem->details() );
1794 resolverProblem->setDescription(
_(
"This request will break your system!"));
1795 description =
_(
"ignore the warning of a broken system");
1796 description += std::string(
" (requires:")+pool_dep2str(pool, what)+
")";
1797 MIL << description << endl;
1798 problemSolution->addFrontDescription (description);
1800 description =
str::form (
_(
"do not ask to install a solvable providing %s"), pool_dep2str(pool, what));
1801 MIL << description << endl;
1802 problemSolution->addDescription (description);
1806 case SOLVER_ERASE | SOLVER_SOLVABLE_PROVIDES:
1808 problemSolution->addSingleAction (Capability(what), REMOVE_EXTRA_CONFLICT);
1809 std::string description =
"";
1812 if (system_conflicts.find(Capability(what)) != system_conflicts.end()) {
1814 resolverProblem->setDetails( resolverProblem->description() +
"\n" + resolverProblem->details() );
1815 resolverProblem->setDescription(
_(
"This request will break your system!"));
1816 description =
_(
"ignore the warning of a broken system");
1817 description += std::string(
" (conflicts:")+pool_dep2str(pool, what)+
")";
1818 MIL << description << endl;
1819 problemSolution->addFrontDescription (description);
1822 description =
str::form (
_(
"do not ask to delete all solvables providing %s"), pool_dep2str(pool, what));
1823 MIL << description << endl;
1824 problemSolution->addDescription (description);
1828 case SOLVER_UPDATE | SOLVER_SOLVABLE:
1830 s = mapSolvable (what);
1831 PoolItem poolItem = _pool.find (s);
1833 if (pool->installed && s.get()->repo == pool->installed) {
1834 problemSolution->addSingleAction (poolItem, KEEP);
1835 std::string description =
str::form (
_(
"do not install most recent version of %s"), s.asString().c_str());
1836 MIL << description << endl;
1837 problemSolution->addDescription (description);
1839 ERR <<
"SOLVER_INSTALL_SOLVABLE_UPDATE " << poolItem <<
" is not selected for installation" << endl;
1842 ERR <<
"SOLVER_INSTALL_SOLVABLE_UPDATE: No item found for " << s.asString() << endl;
1847 MIL <<
"- do something different" << endl;
1848 ERR <<
"No valid solution available" << endl;
1851 }
else if (p == SOLVER_SOLUTION_INFARCH) {
1852 s = mapSolvable (rp);
1853 PoolItem poolItem = _pool.find (s);
1854 if (pool->installed && s.get()->repo == pool->installed) {
1855 problemSolution->addSingleAction (poolItem, LOCK);
1856 std::string description =
str::form (
_(
"keep %s despite the inferior architecture"), s.asString().c_str());
1857 MIL << description << endl;
1858 problemSolution->addDescription (description);
1860 problemSolution->addSingleAction (poolItem, INSTALL);
1861 std::string description =
str::form (
_(
"install %s despite the inferior architecture"), s.asString().c_str());
1862 MIL << description << endl;
1863 problemSolution->addDescription (description);
1865 }
else if (p == SOLVER_SOLUTION_DISTUPGRADE) {
1866 s = mapSolvable (rp);
1867 PoolItem poolItem = _pool.find (s);
1868 if (pool->installed && s.get()->repo == pool->installed) {
1869 problemSolution->addSingleAction (poolItem, LOCK);
1870 std::string description =
str::form (
_(
"keep obsolete %s"), s.asString().c_str());
1871 MIL << description << endl;
1872 problemSolution->addDescription (description);
1874 problemSolution->addSingleAction (poolItem, INSTALL);
1875 std::string description =
str::form (
_(
"install %s from excluded repository"), s.asString().c_str());
1876 MIL << description << endl;
1877 problemSolution->addDescription (description);
1879 }
else if ( p == SOLVER_SOLUTION_BLACK ) {
1882 s = mapSolvable (rp);
1883 PoolItem poolItem = _pool.find (s);
1885 problemSolution->addSingleAction (poolItem, INSTALL);
1886 std::string description;
1887 if ( s.isRetracted() ) {
1889 description = str::Format(
_(
"install %1% although it has been retracted")) % s.asString();
1890 }
else if ( s.isPtf() ) {
1892 description = str::Format(
_(
"allow to install the PTF %1%")) % s.asString();
1895 description = str::Format(
_(
"install %1% although it is blacklisted")) % s.asString();
1897 MIL << description << endl;
1898 problemSolution->addDescription( description );
1899 }
else if ( p > 0 ) {
1901 s = mapSolvable (p);
1902 PoolItem itemFrom = _pool.find (s);
1907 sd = mapSolvable (rp);
1908 PoolItem itemTo = _pool.find (sd);
1909 if (itemFrom && itemTo) {
1910 problemSolution->addSingleAction (itemTo, INSTALL);
1911 int illegal = policy_is_illegal(_satSolver, s.get(), sd.get(), 0);
1913 if ((illegal & POLICY_ILLEGAL_DOWNGRADE) != 0)
1915 std::string description =
str::form (
_(
"downgrade of %s to %s"), s.asString().c_str(), sd.asString().c_str());
1916 MIL << description << endl;
1917 problemSolution->addDescription (description);
1920 if ((illegal & POLICY_ILLEGAL_ARCHCHANGE) != 0)
1922 std::string description =
str::form (
_(
"architecture change of %s to %s"), s.asString().c_str(), sd.asString().c_str());
1923 MIL << description << endl;
1924 problemSolution->addDescription (description);
1927 if ((illegal & POLICY_ILLEGAL_VENDORCHANGE) != 0)
1929 IdString s_vendor( s.vendor() );
1930 IdString sd_vendor( sd.vendor() );
1931 std::string description =
str::form (
_(
"install %s (with vendor change)\n %s --> %s") ,
1932 sd.asString().c_str(),
1933 ( s_vendor ? s_vendor.c_str() :
" (no vendor) " ),
1934 ( sd_vendor ? sd_vendor.c_str() :
" (no vendor) " ) );
1935 MIL << description << endl;
1936 problemSolution->addDescription (description);
1940 std::string description =
str::form (
_(
"replacement of %s with %s"), s.asString().c_str(), sd.asString().c_str());
1941 MIL << description << endl;
1942 problemSolution->addDescription (description);
1945 ERR << s.asString() <<
" or " << sd.asString() <<
" not found" << endl;
1951 std::string description =
str::form (
_(
"deinstallation of %s"), s.asString().c_str());
1952 MIL << description << endl;
1953 problemSolution->addDescription (description);
1954 problemSolution->addSingleAction (itemFrom, REMOVE);
1960 INT <<
"Unknown solution " << p << endl;
1964 resolverProblem->addSolution (problemSolution,
1965 problemSolution->actionCount() > 1 ?
true :
false);
1966 MIL <<
"------------------------------------" << endl;
1971 PoolItem item = _pool.find (sat::Solvable(ignoreId));
1972 ProblemSolutionIgnore *problemSolution =
new ProblemSolutionIgnore(item);
1973 resolverProblem->addSolution (problemSolution,
1975 MIL <<
"ignore some dependencies of " << item << endl;
1976 MIL <<
"------------------------------------" << endl;
1980 resolverProblems.push_back (resolverProblem);
1983 return resolverProblems;
1988 { Resolver( _pool ).applySolutions( solutions ); }
1990 void SATResolver::setLocks()
1995 for (PoolItemList::const_iterator iter = _items_to_lock.begin(); iter != _items_to_lock.end(); ++iter) {
1997 if (iter->status().isInstalled()) {
1999 queue_push( &(_jobQueue), SOLVER_INSTALL | SOLVER_SOLVABLE );
2000 queue_push( &(_jobQueue), ident );
2003 queue_push( &(_jobQueue), SOLVER_ERASE | SOLVER_SOLVABLE |
MAYBE_CLEANDEPS );
2004 queue_push( &(_jobQueue), ident );
2007 MIL <<
"Locked " << icnt <<
" installed items and " << acnt <<
" NOT installed items." << endl;
2013 std::set<IdString> unifiedByName;
2014 for (PoolItemList::const_iterator iter = _items_to_keep.begin(); iter != _items_to_keep.end(); ++iter) {
2015 IdString ident( (*iter)->satSolvable().ident() );
2016 if ( unifiedByName.insert( ident ).second )
2020 MIL <<
"Keep NOT installed name " << ident <<
" (" << *iter <<
")" << endl;
2021 queue_push( &(_jobQueue), SOLVER_ERASE | SOLVER_SOLVABLE_NAME | SOLVER_WEAK |
MAYBE_CLEANDEPS );
2022 queue_push( &(_jobQueue), ident.id() );
2028 void SATResolver::setSystemRequirements()
2030 CapabilitySet system_requires = SystemCheck::instance().requiredSystemCap();
2031 CapabilitySet system_conflicts = SystemCheck::instance().conflictSystemCap();
2033 for (CapabilitySet::const_iterator iter = system_requires.begin(); iter != system_requires.end(); ++iter) {
2034 queue_push( &(_jobQueue), SOLVER_INSTALL | SOLVER_SOLVABLE_PROVIDES );
2035 queue_push( &(_jobQueue), iter->id() );
2036 MIL <<
"SYSTEM Requires " << *iter << endl;
2039 for (CapabilitySet::const_iterator iter = system_conflicts.begin(); iter != system_conflicts.end(); ++iter) {
2040 queue_push( &(_jobQueue), SOLVER_ERASE | SOLVER_SOLVABLE_PROVIDES |
MAYBE_CLEANDEPS );
2041 queue_push( &(_jobQueue), iter->id() );
2042 MIL <<
"SYSTEM Conflicts " << *iter << endl;
2050 IdString rpm(
"rpm" );
2051 for_( it, pool.byIdentBegin(rpm), pool.byIdentEnd(rpm) )
2053 if ( (*it)->isSystem() )
2056 queue_push( &(_jobQueue), SOLVER_INSTALL | SOLVER_SOLVABLE_NAME | SOLVER_ESSENTIAL );
2057 queue_push( &(_jobQueue), archrule.id() );
2068 ::solver_get_userinstalled( _satSolver, ret, GET_USERINSTALLED_NAMES|GET_USERINSTALLED_INVERTED );
2076 ::solver_get_userinstalled( _satSolver, ret, GET_USERINSTALLED_NAMES );
2095 case SOLVER_RULE_DISTUPGRADE:
2096 ret =
str::form (
_(
"%s does not belong to a distupgrade repository"), s.asString().c_str());
2097 case SOLVER_RULE_INFARCH:
2098 ret =
str::form (
_(
"%s has inferior architecture"), s.asString().c_str());
2099 case SOLVER_RULE_UPDATE:
2100 ret =
str::form (
_(
"problem with installed package %s"), s.asString().c_str());
2101 case SOLVER_RULE_JOB:
2102 ret =
_(
"conflicting requests");
2103 case SOLVER_RULE_PKG:
2104 ret =
_(
"some dependency problem");
2105 case SOLVER_RULE_JOB_NOTHING_PROVIDES_DEP:
2106 ret =
str::form (
_(
"nothing provides requested %s"), pool_dep2str(pool, dep));
2107 detail +=
_(
"Have you enabled all requested repositories?");
2108 case SOLVER_RULE_JOB_UNKNOWN_PACKAGE:
2109 ret =
str::form (
_(
"package %s does not exist"), pool_dep2str(pool, dep));
2110 detail +=
_(
"Have you enabled all requested repositories?");
2111 case SOLVER_RULE_JOB_UNSUPPORTED:
2112 ret =
_(
"unsupported request");
2113 case SOLVER_RULE_JOB_PROVIDED_BY_SYSTEM:
2114 ret =
str::form (
_(
"%s is provided by the system and cannot be erased"), pool_dep2str(pool, dep));
2115 case SOLVER_RULE_PKG_NOT_INSTALLABLE:
2116 ret =
str::form (
_(
"%s is not installable"), s.asString().c_str());
2117 case SOLVER_RULE_PKG_NOTHING_PROVIDES_DEP:
2119 ret =
str::form (
_(
"nothing provides %s needed by %s"), pool_dep2str(pool, dep), s.asString().c_str());
2120 case SOLVER_RULE_PKG_SAME_NAME:
2121 ret =
str::form (
_(
"cannot install both %s and %s"), s.asString().c_str(), s2.asString().c_str());
2122 case SOLVER_RULE_PKG_CONFLICTS:
2123 ret =
str::form (
_(
"%s conflicts with %s provided by %s"), s.asString().c_str(), pool_dep2str(pool, dep), s2.asString().c_str());
2124 case SOLVER_RULE_PKG_OBSOLETES:
2125 ret =
str::form (
_(
"%s obsoletes %s provided by %s"), s.asString().c_str(), pool_dep2str(pool, dep), s2.asString().c_str());
2126 case SOLVER_RULE_PKG_INSTALLED_OBSOLETES:
2127 ret =
str::form (
_(
"installed %s obsoletes %s provided by %s"), s.asString().c_str(), pool_dep2str(pool, dep), s2.asString().c_str());
2128 case SOLVER_RULE_PKG_SELF_CONFLICT:
2129 ret =
str::form (
_(
"solvable %s conflicts with %s provided by itself"), s.asString().c_str(), pool_dep2str(pool, dep));
2130 case SOLVER_RULE_PKG_REQUIRES: {
2131 ret =
str::form (
_(
"%s requires %s, but this requirement cannot be provided"), s.asString().c_str(), pool_dep2str(pool, dep));
2132 if (providerlistInstalled.size() > 0) {
2133 detail +=
_(
"deleted providers: ");
2134 detail +=
_(
"\nnot installable providers: ");
2135 detail =
_(
"not installable providers: ");
2138 if (p == SOLVER_SOLUTION_JOB) {
2139 case SOLVER_INSTALL | SOLVER_SOLVABLE: {
2140 std::string description =
str::form (
_(
"remove lock to allow removal of %s"), s.asString().c_str() );
2141 std::string description =
str::form (
_(
"do not install %s"), s.asString().c_str());
2142 case SOLVER_ERASE | SOLVER_SOLVABLE: {
2143 std::string description =
str::form (
_(
"keep %s"), s.asString().c_str());
2144 std::string description =
str::form (
_(
"remove lock to allow installation of %s"),
itemToString( poolItem ).c_str());
2145 case SOLVER_INSTALL | SOLVER_SOLVABLE_NAME:
2146 std::string description =
str::form (
_(
"do not install %s"), ident.c_str() );
2147 case SOLVER_ERASE | SOLVER_SOLVABLE_NAME:
2148 std::string description =
str::form (
_(
"keep %s"), ident.c_str());
2149 case SOLVER_INSTALL | SOLVER_SOLVABLE_PROVIDES:
2150 resolverProblem->setDescription(
_(
"This request will break your system!"));
2151 description =
_(
"ignore the warning of a broken system");
2152 description =
str::form (
_(
"do not ask to install a solvable providing %s"), pool_dep2str(pool, what));
2153 case SOLVER_ERASE | SOLVER_SOLVABLE_PROVIDES:
2154 resolverProblem->setDescription(
_(
"This request will break your system!"));
2155 description =
_(
"ignore the warning of a broken system");
2156 description =
str::form (
_(
"do not ask to delete all solvables providing %s"), pool_dep2str(pool, what));
2157 case SOLVER_UPDATE | SOLVER_SOLVABLE:
2158 std::string description =
str::form (
_(
"do not install most recent version of %s"), s.asString().c_str());
2160 }
else if (p == SOLVER_SOLUTION_INFARCH) {
2161 std::string description =
str::form (
_(
"keep %s despite the inferior architecture"), s.asString().c_str());
2162 std::string description =
str::form (
_(
"install %s despite the inferior architecture"), s.asString().c_str());
2164 }
else if (p == SOLVER_SOLUTION_DISTUPGRADE) {
2165 std::string description =
str::form (
_(
"keep obsolete %s"), s.asString().c_str());
2166 std::string description =
str::form (
_(
"install %s from excluded repository"), s.asString().c_str());
2168 }
else if ( p == SOLVER_SOLUTION_BLACK ) {
2169 description = str::Format(
_(
"install %1% although it has been retracted")) % s.asString();
2170 description = str::Format(
_(
"allow to install the PTF %1%")) % s.asString();
2171 description = str::Format(
_(
"install %1% although it is blacklisted")) % s.asString();
2173 }
else if ( p > 0 ) {
2174 std::string description =
str::form (
_(
"downgrade of %s to %s"), s.asString().c_str(), sd.asString().c_str());
2175 std::string description =
str::form (
_(
"architecture change of %s to %s"), s.asString().c_str(), sd.asString().c_str());
2176 std::string description =
str::form (
_(
"install %s (with vendor change)\n %s --> %s") ,
2177 std::string description =
str::form (
_(
"replacement of %s with %s"), s.asString().c_str(), sd.asString().c_str());
2179 std::string description =
str::form (
_(
"deinstallation of %s"), s.asString().c_str());
#define for_(IT, BEG, END)
Convenient for-loops using iterator.
Reference counted access to a Tp object calling a custom Dispose function when the last AutoDispose h...
Access to the sat-pools string space.
Combining sat::Solvable and ResStatus.
ResStatus & status() const
Returns the current status.
sat::Solvable buddy() const
Return the buddy we share our status object with.
std::string alias() const
Short unique string to identify a repo.
PoolItem find(const sat::Solvable &slv_r) const
Return the corresponding PoolItem.
static ResPool instance()
Singleton ctor.
static const ResStatus toBeInstalled
bool setToBeUninstalled(TransactByValue causer)
bool isToBeInstalled() const
bool setToBeInstalled(TransactByValue causer)
TransactValue getTransactValue() const
static const ResStatus toBeUninstalledDueToUpgrade
static const ResStatus toBeUninstalled
bool isToBeUninstalled() const
bool isToBeUninstalledDueToUpgrade() const
bool resetTransact(TransactByValue causer_r)
Not the same as setTransact( false ).
bool setToBeUninstalledDueToUpgrade(TransactByValue causer)
bool isUninstalled() const
bool equivalent(const Vendor &lVendor, const Vendor &rVendor) const
Return whether two vendor strings should be treated as the same vendor.
bool relaxedEquivalent(const Vendor &lVendor, const Vendor &rVendor) const
Like equivalent but always unifies suse and openSUSE vendor.
static const VendorAttr & instance()
(Pseudo)Singleton, mapped to the current Target::vendorAttr settings or to noTargetInstance.
static ZConfig & instance()
Singleton ctor.
static Pool instance()
Singleton ctor.
void prepare() const
Update housekeeping data if necessary (e.g.
detail::CPool * get() const
Expert backdoor.
Libsolv Id queue wrapper.
void push(value_type val_r)
Push a value to the end off the Queue.
A Solvable object within the sat Pool.
std::string asString() const
String representation "ident-edition.arch" or "noSolvable".
bool isSystem() const
Return whether this Solvable belongs to the system repo.
static const IdString ptfToken
Indicator provides ptf()
static const IdString retractedToken
Indicator provides retracted-patch-package()
bool isKind(const ResKind &kind_r) const
Test whether a Solvable is of a certain ResKind.
Repository repository() const
The Repository this Solvable belongs to.
bool operator()(const PoolItem &item)
CheckIfUpdate(const sat::Solvable &installed_r)
static Ptr get(const pool::ByIdent &ident_r)
Get the Selctable.
std::ostream & dumpOn(std::ostream &str, const zypp::shared_ptr< void > &obj)
Chain< TACondition, TBCondition > chain(TACondition conda_r, TBCondition condb_r)
Convenience function for creating a Chain from two conditions conda_r and condb_r.
std::unary_function< PoolItem, bool > PoolItemFilterFunctor
std::unary_function< ResObject::constPtr, bool > ResObjectFilterFunctor
::s_Solver CSolver
Wrapped libsolv C data type exposed as backdoor.
int IdType
Generic Id type.
::s_Pool CPool
Wrapped libsolv C data type exposed as backdoor.
unsigned SolvableIdType
Id type to connect Solvable and sat-solvable.
bool compareByNVR(const SolvableType< Derived > &lhs, const Solvable &rhs)
This is an overloaded member function, provided for convenience. It differs from the above function o...
Queue SolvableQueue
Queue with Solvable ids.
Queue StringQueue
Queue with String ids.
bool sameNVRA(const SolvableType< Derived > &lhs, const Solvable &rhs)
This is an overloaded member function, provided for convenience. It differs from the above function o...
static void SATSolutionToPool(PoolItem item, const ResStatus &status, const ResStatus::TransactByValue causer)
int vendorCheck(sat::detail::CPool *pool, Solvable *solvable1, Solvable *solvable2)
sat::Solvable mapBuddy(sat::Solvable item_r)
void establish(sat::Queue &pseudoItems_r, sat::Queue &pseudoFlags_r)
ResPool helper to compute the initial status of Patches etc.
int relaxedVendorCheck(sat::detail::CPool *pool, Solvable *solvable1, Solvable *solvable2)
IMPL_PTR_TYPE(SATResolver)
std::list< SolverQueueItem_Ptr > SolverQueueItemList
std::string itemToString(const PoolItem &item)
const std::string & asString(const std::string &t)
Global asString() that works with std::string too.
std::string form(const char *format,...) __attribute__((format(printf
Printf style construction of std::string.
bool isPseudoInstalled(ResKind kind_r)
Those are denoted to be installed, if the solver verifies them as being satisfied.
Easy-to use interface to the ZYPP dependency resolver.
std::unordered_set< Capability > CapabilitySet
@ language
language support
ResolverFocus
The resolvers general attitude.
@ Update
Focus on updating requested packages and their dependencies as much as possible.
@ Default
Request the standard behavior (as defined in zypp.conf or 'Job')
@ Installed
Focus on applying as little changes to the installed packages as needed.
@ Job
Focus on installing the best version of the requested packages.
std::list< ResolverProblem_Ptr > ResolverProblemList
std::list< ProblemSolution_Ptr > ProblemSolutionList
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.
bool isKind(const ResKind &kind_r) const
Solvable satSolvable() const
Return the corresponding sat::Solvable.
std::string asString() const
bool multiversionInstall() const
bool operator()(PoolItem p)
FindPackage(ProblemSolutionCombi *p, const TransactionKind act)
ProblemSolutionCombi * problemSolution
Commit helper functor distributing PoolItem by status into lists.
PoolItemList & _items_to_lock
SATCollectTransact(PoolItemList &items_to_install_r, PoolItemList &items_to_remove_r, PoolItemList &items_to_lock_r, PoolItemList &items_to_keep_r, bool solveSrcPackages_r)
PoolItemList & _items_to_install
PoolItemList & _items_to_remove
PoolItemList & _items_to_keep
bool operator()(const PoolItem &item_r)