#include "zypp/ResFilters.h"
#include "zypp/sat/Pool.h"
#include "zypp/sat/Solvable.h"
+#include "zypp/sat/Transaction.h"
+#include "zypp/ResolverProblem.h"
#define MAXSOLVERRUNS 5
//---------------------------------------------------------------------------
-std::ostream &
-Resolver::dumpOn( std::ostream & os ) const
+std::ostream & Resolver::dumpOn( std::ostream & os ) const
{
- return os << "<resolver/>";
+ os << "<resolver>" << endl;
+ #define OUTS(t) os << " " << #t << ":\t" << t << endl;
+ OUTS( _forceResolve );
+ OUTS( _upgradeMode );
+ OUTS( _updateMode );
+ OUTS( _verifying );
+ OUTS( _onlyRequires );
+ OUTS( _allowVendorChange );
+ OUTS( _solveSrcPackages );
+ OUTS( _cleandepsOnRemove );
+ OUTS( _ignoreAlreadyRecommended );
+ #undef OUT
+ return os << "<resolver/>";
}
: _pool(pool)
, _satResolver(NULL)
, _poolchanged(_pool.serial() )
- , _testing(false)
- , _forceResolve(false)
- , _upgradeMode(false)
- , _verifying(false)
- , _onlyRequires(indeterminate)
- , _ignorealreadyrecommended(false)
+ , _forceResolve (false)
+ , _upgradeMode (false)
+ , _updateMode (false)
+ , _verifying (false)
+ , _onlyRequires ( ZConfig::instance().solver_onlyRequires() )
+ , _allowVendorChange ( ZConfig::instance().solver_allowVendorChange() )
+ , _solveSrcPackages ( false )
+ , _cleandepsOnRemove ( ZConfig::instance().solver_cleandepsOnRemove() )
+ , _ignoreAlreadyRecommended ( true )
{
sat::Pool satPool( sat::Pool::instance() );
Resolver::~Resolver()
{
+ delete _satResolver;
}
//---------------------------------------------------------------------------
+// forward flags too SATResolver
+#define ZOLV_FLAG_TRIBOOL( ZSETTER, ZGETTER, ZVARNAME, ZVARDEFAULT ) \
+ void Resolver::ZSETTER( TriBool state_r ) \
+ { _satResolver->ZVARNAME = indeterminate(state_r) ? ZVARDEFAULT : bool(state_r); } \
+ bool Resolver::ZGETTER() const \
+ { return _satResolver->ZVARNAME; } \
+
+ZOLV_FLAG_TRIBOOL( dupSetAllowDowngrade, dupAllowDowngrade, _dup_allowdowngrade, true )
+ZOLV_FLAG_TRIBOOL( dupSetAllowNameChange, dupAllowNameChange, _dup_allownamechange, true )
+ZOLV_FLAG_TRIBOOL( dupSetAllowArchChange, dupAllowArchChange, _dup_allowarchchange, true )
+ZOLV_FLAG_TRIBOOL( dupSetAllowVendorChange, dupAllowVendorChange, _dup_allowvendorchange, true )
+
+#undef ZOLV_FLAG_TRIBOOL
+//---------------------------------------------------------------------------
+
+void Resolver::setAllowVendorChange( TriBool state_r )
+{
+ _allowVendorChange = indeterminate(state_r) ? ZConfig::instance().solver_allowVendorChange() : bool(state_r);
+}
+
+void Resolver::setOnlyRequires( TriBool state_r )
+{
+ _onlyRequires = indeterminate(state_r) ? ZConfig::instance().solver_onlyRequires() : bool(state_r);
+}
-ResPool
-Resolver::pool (void) const
+void Resolver::setCleandepsOnRemove( TriBool state_r )
{
- return _pool;
+ _cleandepsOnRemove = indeterminate(state_r) ? ZConfig::instance().solver_cleandepsOnRemove() : bool(state_r);
}
-void
-Resolver::reset (bool keepExtras )
+//---------------------------------------------------------------------------
+
+ResPool Resolver::pool() const
+{ return _pool; }
+
+void Resolver::reset( bool keepExtras )
{
- _verifying = false;
+ _verifying = false;
if (!keepExtras) {
_extra_requires.clear();
_installedSatisfied.clear();
}
-void
-Resolver::doUpdate()
+bool Resolver::doUpgrade()
{
+ // Setting Resolver to upgrade mode. SAT solver will do the update
+ _upgradeMode = true;
+ return resolvePool();
+}
+
+void Resolver::doUpdate()
+{
+ _updateMode = true;
return _satResolver->doUpdate();
}
PoolItemList Resolver::problematicUpdateItems() const
{ return _satResolver->problematicUpdateItems(); }
-void
-Resolver::addExtraRequire (const Capability & capability)
-{
- _extra_requires.insert (capability);
-}
+void Resolver::addExtraRequire( const Capability & capability )
+{ _extra_requires.insert (capability); }
-void
-Resolver::removeExtraRequire (const Capability & capability)
-{
- _extra_requires.erase (capability);
-}
+void Resolver::removeExtraRequire( const Capability & capability )
+{ _extra_requires.erase (capability); }
-void
-Resolver::addExtraConflict (const Capability & capability)
-{
- _extra_conflicts.insert (capability);
-}
+void Resolver::addExtraConflict( const Capability & capability )
+{ _extra_conflicts.insert (capability); }
-void
-Resolver::removeExtraConflict (const Capability & capability)
-{
- _extra_conflicts.erase (capability);
-}
+void Resolver::removeExtraConflict( const Capability & capability )
+{ _extra_conflicts.erase (capability); }
-void Resolver::removeQueueItem (const SolverQueueItem_Ptr item)
+void Resolver::removeQueueItem( SolverQueueItem_Ptr item )
{
bool found = false;
for (SolverQueueItemList::const_iterator iter = _added_queue_items.begin();
_removed_queue_items.unique ();
}
}
-void Resolver::addQueueItem (const SolverQueueItem_Ptr item)
+
+void Resolver::addQueueItem( SolverQueueItem_Ptr item )
{
bool found = false;
for (SolverQueueItemList::const_iterator iter = _removed_queue_items.begin();
if (!found) {
_added_queue_items.push_back (item);
_added_queue_items.unique ();
- }
+ }
}
-void
-Resolver::addWeak (const PoolItem item)
-{
- _addWeak.push_back (item);
-}
+void Resolver::addWeak( const PoolItem & item )
+{ _addWeak.push_back( item ); }
//---------------------------------------------------------------------------
};
-bool
-Resolver::verifySystem ()
+bool Resolver::verifySystem()
{
UndoTransact resetting (ResStatus::APPL_HIGH);
_DEBUG ("Resolver::verifySystem() ");
-
- _verifying = true;
+
+ _verifying = true;
invokeOnEach ( _pool.begin(), _pool.end(),
resfilter::ByTransact( ), // Resetting all transcations
//----------------------------------------------------------------------------
// undo
-
-void
-Resolver::undo(void)
+void Resolver::undo()
{
UndoTransact info(ResStatus::APPL_LOW);
MIL << "*** undo ***" << endl;
// Additional QueueItems which has to be regarded by the solver
_removed_queue_items.clear();
- _added_queue_items.clear();
+ _added_queue_items.clear();
return;
}
-void
-Resolver::solverInit()
+void Resolver::solverInit()
{
- // Solving with the satsolver
+ // Solving with libsolv
static bool poolDumped = false;
MIL << "-------------- Calling SAT Solver -------------------" << endl;
if ( getenv("ZYPP_FULLLOG") ) {
}
}
- _satResolver->setFixsystem(false);
- _satResolver->setIgnorealreadyrecommended(false);
- _satResolver->setAllowdowngrade(false);
- _satResolver->setAllowarchchange(false);
- _satResolver->setAllowvendorchange(false);
- _satResolver->setAllowuninstall(false);
- _satResolver->setUpdatesystem(false);
- _satResolver->setAllowvirtualconflicts(false);
- _satResolver->setNoupdateprovide(false);
- _satResolver->setDosplitprovides(false);
-
+ _satResolver->setFixsystem ( isVerifyingMode() );
+ _satResolver->setIgnorealreadyrecommended ( ignoreAlreadyRecommended() );
+ _satResolver->setOnlyRequires ( onlyRequires() );
+ _satResolver->setAllowdowngrade (false);
+ _satResolver->setAllowarchchange (false);
+ _satResolver->setAllowvendorchange ( allowVendorChange() );
+ _satResolver->setAllowuninstall ( forceResolve() );
+ _satResolver->setUpdatesystem (false);
+ _satResolver->setNoupdateprovide (false);
+ _satResolver->setDosplitprovides (true);
+ _satResolver->setSolveSrcPackages ( solveSrcPackages() );
+ _satResolver->setCleandepsOnRemove ( cleandepsOnRemove() );
+
+ _satResolver->setDistupgrade (_upgradeMode);
if (_upgradeMode) {
- _satResolver->setAllowdowngrade(true);
- _satResolver->setUpdatesystem(false); // not needed cause packages has already been evaluteted by distupgrade
- _satResolver->setDosplitprovides(true);
- if ( !getenv("ZYPP_NO_SAT_UPDATE") ) {
- MIL << "-------------- Calling SAT Solver in distupgrade mode -------------------" << endl;
- // SAT solver will do the dist update
- _satResolver->setAllowarchchange(true);
- _satResolver->setAllowvendorchange(true);
- _satResolver->setUpdatesystem(true);
- _satResolver->setDistupgrade(true);
- _satResolver->setDistupgrade_removeunsupported(false);
- }
+ // may overwrite some settings
+ _satResolver->setDistupgrade_removeunsupported (false);
}
- if (_forceResolve)
- _satResolver->setAllowuninstall(true);
-
- if (_onlyRequires == indeterminate)
- _satResolver->setOnlyRequires(ZConfig::instance().solver_onlyRequires());
- else if (_onlyRequires)
- _satResolver->setOnlyRequires(true);
- else
- _satResolver->setOnlyRequires(false);
-
- if (_verifying)
- _satResolver->setFixsystem(true);
-
- if (_ignorealreadyrecommended)
- _satResolver->setIgnorealreadyrecommended(true);
-
// Resetting additional solver information
_isInstalledBy.clear();
_installs.clear();
_installedSatisfied.clear();
}
-bool
-Resolver::resolvePool()
+bool Resolver::resolvePool()
{
solverInit();
- return _satResolver->resolvePool(_extra_requires, _extra_conflicts, _addWeak);
+ return _satResolver->resolvePool(_extra_requires, _extra_conflicts, _addWeak, _upgradeRepos );
}
-bool
-Resolver::resolveQueue(solver::detail::SolverQueueItemList & queue)
+bool Resolver::resolveQueue( solver::detail::SolverQueueItemList & queue )
{
solverInit();
-
+
// add/remove additional SolverQueueItems
for (SolverQueueItemList::const_iterator iter = _removed_queue_items.begin();
iter != _removed_queue_items.end(); iter++) {
for (SolverQueueItemList::const_iterator iterQueue = queue.begin(); iterQueue != queue.end(); iterQueue++) {
- if ( (*iterQueue)->cmp(*iter) == 0) {
+ if ( (*iterQueue)->cmp(*iter) == 0) {
MIL << "remove from queue" << *iter;
queue.remove(*iterQueue);
break;
- }
+ }
}
}
if ( (*iterQueue)->cmp(*iter) == 0) {
found = true;
break;
- }
+ }
}
if (!found) {
- MIL << "add to queue" << *iter;
+ MIL << "add to queue" << *iter;
queue.push_back(*iter);
}
}
// give the user a chance for changing these decisions again.
_removed_queue_items.clear();
_added_queue_items.clear();
-
+
return _satResolver->resolveQueue(queue, _addWeak);
}
+sat::Transaction Resolver::getTransaction()
+{
+ // FIXME: That's an ugly way of pushing autoInstalled into the transaction.
+ sat::Transaction ret( sat::Transaction::loadFromPool );
+ ret.autoInstalled( _satResolver->autoInstalled() );
+ return ret;
+}
+
//----------------------------------------------------------------------------
// Getting more information about the solve results
+ResolverProblemList Resolver::problems() const
+{
+ MIL << "Resolver::problems()" << endl;
+ return _satResolver->problems();
+}
-void
-Resolver::collectResolverInfo(void)
+void Resolver::applySolutions( const ProblemSolutionList & solutions )
+{
+ for_( iter, solutions.begin(), solutions.end() )
+ {
+ ProblemSolution_Ptr solution = *iter;
+ if ( !solution->apply( *this ) )
+ break;
+ }
+}
+
+void Resolver::collectResolverInfo()
{
if ( _satResolver
&& _isInstalledBy.empty()
sat::WhatProvides possibleProviders(*capIt);
for_( iter, possibleProviders.begin(), possibleProviders.end() ) {
PoolItem provider = ResPool::instance().find( *iter );
-
+
// searching if this provider will already be installed
bool found = false;
bool alreadySetForInstallation = false;
_isInstalledBy.insert (make_pair( provider, capKindisInstalledBy));
} else {
// no initial installation cause it has been set be e.g. user
- ItemCapKind capKindisInstalledBy( *instIter, *capIt, Dep::REQUIRES, false );
- _isInstalledBy.insert (make_pair( provider, capKindisInstalledBy));
+ ItemCapKind capKindisInstalledBy( *instIter, *capIt, Dep::REQUIRES, false );
+ _isInstalledBy.insert (make_pair( provider, capKindisInstalledBy));
}
ItemCapKind capKindisInstalledBy( provider, *capIt, Dep::REQUIRES, !alreadySetForInstallation );
- _installs.insert (make_pair( *instIter, capKindisInstalledBy));
+ _installs.insert (make_pair( *instIter, capKindisInstalledBy));
}
if (provider.status().staysInstalled()) { // Is already satisfied by an item which is installed
ItemCapKind capKindisInstalledBy( provider, *capIt, Dep::REQUIRES, false );
_satifiedByInstalled.insert (make_pair( *instIter, capKindisInstalledBy));
- ItemCapKind installedSatisfied( *instIter, *capIt, Dep::REQUIRES, false );
- _installedSatisfied.insert (make_pair( provider, installedSatisfied));
+ ItemCapKind installedSatisfied( *instIter, *capIt, Dep::REQUIRES, false );
+ _installedSatisfied.insert (make_pair( provider, installedSatisfied));
}
}
}
sat::WhatProvides possibleProviders(*capIt);
for_( iter, possibleProviders.begin(), possibleProviders.end() ) {
PoolItem provider = ResPool::instance().find( *iter );
-
+
// searching if this provider will already be installed
bool found = false;
bool alreadySetForInstallation = false;
_isInstalledBy.insert (make_pair( provider, capKindisInstalledBy));
} else {
// no initial installation cause it has been set be e.g. user
- ItemCapKind capKindisInstalledBy( *instIter, *capIt, Dep::RECOMMENDS, false );
- _isInstalledBy.insert (make_pair( provider, capKindisInstalledBy));
+ ItemCapKind capKindisInstalledBy( *instIter, *capIt, Dep::RECOMMENDS, false );
+ _isInstalledBy.insert (make_pair( provider, capKindisInstalledBy));
}
ItemCapKind capKindisInstalledBy( provider, *capIt, Dep::RECOMMENDS, !alreadySetForInstallation );
- _installs.insert (make_pair( *instIter, capKindisInstalledBy));
+ _installs.insert (make_pair( *instIter, capKindisInstalledBy));
}
if (provider.status().staysInstalled()) { // Is already satisfied by an item which is installed
ItemCapKind capKindisInstalledBy( provider, *capIt, Dep::RECOMMENDS, false );
_satifiedByInstalled.insert (make_pair( *instIter, capKindisInstalledBy));
- ItemCapKind installedSatisfied( *instIter, *capIt, Dep::RECOMMENDS, false );
- _installedSatisfied.insert (make_pair( provider, installedSatisfied));
- }
+ ItemCapKind installedSatisfied( *instIter, *capIt, Dep::RECOMMENDS, false );
+ _installedSatisfied.insert (make_pair( provider, installedSatisfied));
+ }
}
}
_isInstalledBy.insert (make_pair( *instIter, capKindisInstalledBy));
} else {
// no initial installation cause it has been set be e.g. user
- ItemCapKind capKindisInstalledBy( provider, *capIt, Dep::SUPPLEMENTS, false );
- _isInstalledBy.insert (make_pair( *instIter, capKindisInstalledBy));
+ ItemCapKind capKindisInstalledBy( provider, *capIt, Dep::SUPPLEMENTS, false );
+ _isInstalledBy.insert (make_pair( *instIter, capKindisInstalledBy));
}
ItemCapKind capKindisInstalledBy( *instIter, *capIt, Dep::SUPPLEMENTS, !alreadySetForInstallation );
_installs.insert (make_pair( provider, capKindisInstalledBy));
ItemCapKind capKindisInstalledBy( *instIter, *capIt, Dep::SUPPLEMENTS, !alreadySetForInstallation );
_satifiedByInstalled.insert (make_pair( provider, capKindisInstalledBy));
- ItemCapKind installedSatisfied( provider, *capIt, Dep::SUPPLEMENTS, false );
- _installedSatisfied.insert (make_pair( *instIter, installedSatisfied));
+ ItemCapKind installedSatisfied( provider, *capIt, Dep::SUPPLEMENTS, false );
+ _installedSatisfied.insert (make_pair( *instIter, installedSatisfied));
}
}
}
}
-const ItemCapKindList Resolver::isInstalledBy (const PoolItem item) {
+ItemCapKindList Resolver::isInstalledBy( const PoolItem & item )
+{
ItemCapKindList ret;
collectResolverInfo();
return ret;
}
-const ItemCapKindList Resolver::installs (const PoolItem item) {
+ItemCapKindList Resolver::installs( const PoolItem & item )
+{
ItemCapKindList ret;
collectResolverInfo();
return ret;
}
-const ItemCapKindList Resolver::satifiedByInstalled (const PoolItem item) {
+ItemCapKindList Resolver::satifiedByInstalled( const PoolItem & item )
+{
ItemCapKindList ret;
collectResolverInfo();
return ret;
}
-const ItemCapKindList Resolver::installedSatisfied (const PoolItem item) {
+ItemCapKindList Resolver::installedSatisfied( const PoolItem & item )
+{
ItemCapKindList ret;
collectResolverInfo();