zypp/Resolver.h

   1 /*---------------------------------------------------------------------\
   2 |                          ____ _   __ __ ___                          |
   3 |                         |__  / \ / / . \ . \                         |
   4 |                           / / \ V /|  _/  _/                         |
   5 |                          / /__ | | | | | |                           |
   6 |                         /_____||_| |_| |_|                           |
   7 |                                                                      |
   8 \---------------------------------------------------------------------*/
   9 /** \file       zypp/Resolver.h
  10  *
  11 */
  12 #ifndef ZYPP_RESOLVER_H
  13 #define ZYPP_RESOLVER_H
  14
  15 #include <iosfwd>
  16 #include <functional>
  17
  18 #include "zypp/base/ReferenceCounted.h"
  19 #include "zypp/base/PtrTypes.h"
  20
  21 #include "zypp/ResPool.h"
  22 #include "zypp/UpgradeStatistics.h"
  23 #include "zypp/solver/detail/Resolver.h"
  24 #include "zypp/solver/detail/ResolverContext.h"
  25 #include "zypp/ProblemTypes.h"
  26
  27 ///////////////////////////////////////////////////////////////////
  28 namespace zypp
  29 { /////////////////////////////////////////////////////////////////
  30
  31
  32
  33   ///////////////////////////////////////////////////////////////////
  34   //
  35   //    CLASS NAME : Resolver
  36   //
  37   /** Resolver interface.
  38   */
  39   class Resolver : public base::ReferenceCounted, private base::NonCopyable
  40   {
  41   public:
  42
  43     /** Ctor */
  44     Resolver( const ResPool & pool );
  45     /** Dtor */
  46     virtual ~Resolver();
  47
  48     /**
  49      * Resolve package dependencies:
  50      *
  51      * Verify consistency of system
  52      *
  53      **/
  54     bool verifySystem ();
  55
  56     /**
  57      * Resolve package dependencies:
  58      *
  59      * Verify consistency of system
  60      * considerNewHardware = install packages which depends on
  61      * new hardware
  62      *
  63      **/
  64     bool verifySystem (bool considerNewHardware);
  65
  66     /**
  67      * Establish state of 'higher level' Resolvables in Pool
  68      *
  69      * Must be called when dealing with non-package resolvables,
  70      * like Patches, Patterns, and Products
  71      *
  72      * Must be called with a 'plain' pool, e.g. no additonal
  73      * transacts set.
  74      *
  75      * return true if it was successful
  76      * return false if not (this will only happen if other
  77      *   transactions are in the pool which will lead to
  78      *   no solution)
  79      **/
  80     bool establishPool (void);
  81
  82     /**
  83      * go through all package 'freshen' dependencies and
  84      * schedule matches for installation.
  85      *
  86      * To be called at begin of installation and upgrade.
  87      * Probably also useful after adding a new package
  88      * repository.
  89      *
  90      * return true if it was successful
  91      * return false if not (this will only happen if other
  92      *   transactions are in the pool which will lead to
  93      *   no solution)
  94      **/
  95     bool freshenPool (void);
  96
  97     /**
  98      * Resolve package dependencies:
  99      *
 100      * Try to execute all pending transactions (there may be more than
 101      * one!).
 102      * The solver pays attention to the BEST packages only in order to
 103      * come to a solution.
 104      * If there has not been found a valid results all other branches
 105      * (e.G. packages with older version numbers, worse architecture)
 106      *  will be regarded.
 107      *
 108      * Returns "true" on success (i.e., if there were no problems that
 109      * need user interaction) and "false" if there were problems.  In
 110      * the latter case, use problems() and later applySolutions()
 111      * below.
 112      **/
 113     bool resolvePool (void);
 114
 115     /**
 116      * Resolve package dependencies:
 117      *
 118      * Try to execute all pending transactions (there may be more than
 119      * one!).
 120      * If tryAllPossibilities is false, restrict searches for matching
 121      *  requirements to best architecture, highest version.
 122      * If tryAllPossibilities is true, evaluate all possible matches
 123      *  for a requirement.
 124      *
 125      * Returns "true" on success (i.e., if there were no problems that
 126      * need user interaction) and "false" if there were problems.  In
 127      * the latter case, use problems() and later applySolutions()
 128      * below.
 129      **/
 130     bool resolvePool (bool tryAllPossibilities);
 131
 132
 133     /*
 134      * Undo solver changes done in resolvePool()
 135      * Throwing away all ignored dependencies.
 136      */
 137     void undo( void );
 138
 139     /*
 140      * Get the most recent resolver context
 141      *
 142      * It will be NULL if resolvePool() or establishPool() was never called.
 143      * Depending on the return code of the last resolvePool() call,
 144      * it _either_ points to a valid or an invalid solution.
 145      */
 146     solver::detail::ResolverContext_Ptr context (void) const;
 147
 148     /**
 149      * Do an distribution upgrade
 150      *
 151      * This will run a full upgrade on the pool, taking all upgrade
 152      * dependencies (provide/obsolete for package renames, split-
 153      * provides, etc.) into account and actually removing installed
 154      * packages if no upgrade exists.
 155      *
 156      * To be run with great caution. It basically brings your
 157      * system 'back to start'.
 158      * Quite helpful to get back to a 'sane state'. Quite disastrous
 159      * since you'll loose all non-distribution packages
 160      **/
 161     void doUpgrade( UpgradeStatistics & opt_stats_r );
 162
 163     /**
 164      * Return the list of problematic update items
 165      * i.e. locked ones (due to foreign vendor)
 166      **/
 167     std::list<PoolItem_Ref> problematicUpdateItems( void ) const;
 168
 169     /**
 170      * Return the dependency problems found by the last call to
 171      * resolveDependencies(). If there were no problems, the returned
 172      * list will be empty.
 173      **/
 174     ResolverProblemList problems();
 175
 176     /**
 177      * Return more solver information if an error has happened.
 178      **/
 179
 180     std::list<std::string> problemDescription( void ) const;
 181
 182     /**
 183      * Apply problem solutions. No more than one solution per problem
 184      * can be applied.
 185      **/
 186     void applySolutions( const ProblemSolutionList & solutions );
 187
 188     Arch architecture() const;
 189     void setArchitecture( const Arch & arch);
 190
 191     /**
 192      * Remove resolvables which are conflicts with others or
 193      * have unfulfilled requirements.
 194      * This behaviour is favourited by ZMD.
 195      **/
 196     void setForceResolve (const bool force);
 197     const bool forceResolve();
 198
 199     /**
 200      * Prefer the result with the newest version if there are more solver
 201      * results.
 202      **/
 203     void setPreferHighestVersion (const bool highestVersion);
 204     const bool preferHighestVersion();
 205
 206     /**
 207      * transact a single ResObject
 208      *
 209      * Installs (install == true) or removes (install == false) all required
 210      * and recommended packages(!) of \c robj
 211      * (More or less a 'single step' resolver call)
 212      *
 213      * returns false if requirements are not all fulfillable
 214      *
 215      */
 216     bool transactResObject( ResObject::constPtr robj, bool install = true);
 217
 218     /**
 219      * transact all objects of this kind
 220      *
 221      * Look through the pool and runs transactResObject, first for removes
 222      * then for installs
 223      * (More or less a 'single step' resolver call)
 224      *
 225      * returns false if any transactResObject() call returned false.
 226      *
 227      */
 228     bool transactResKind( Resolvable::Kind kind );
 229
 230     /**
 231      * reset any transact states
 232      *
 233      * Look through the pool and clear transact state.
 234      * It will only reset states which have an equal or
 235      * lower causer
 236      *
 237      */
 238     void transactReset( ResStatus::TransactByValue causer );
 239
 240     /**
 241      * Setting solver timeout
 242      *
 243      * Stop solving after a given timeframe (seconds)
 244      * seconds = 0 : No timeout
 245      *
 246      */
 247     void setTimeout( int seconds );
 248
 249     /**
 250      * Getting solver timeout in seconds
 251      *
 252      */
 253     int timeout();
 254
 255     /**
 256      * Restricting solver passes
 257      *
 258      * Stop solving after a given amount of passes
 259      * count = 0 : No restriction
 260      *
 261      */
 262     void setMaxSolverPasses (int count);
 263
 264     /**
 265      * Count of max solver passes
 266      *
 267      */
 268     int maxSolverPasses ();
 269
 270     /**
 271      * Generates a solver Testcase of the current state
 272      *
 273      * return true if it was successful
 274      */
 275     bool createSolverTestcase (const std::string & dumpPath = "/var/log/YaST2/solverTestcase");
 276
 277   protected:
 278
 279   private:
 280     solver::detail::Resolver_Ptr _pimpl;
 281   };
 282   ///////////////////////////////////////////////////////////////////
 283
 284   /////////////////////////////////////////////////////////////////
 285 } // namespace zypp
 286 ///////////////////////////////////////////////////////////////////
 287 #endif // ZYPP_RESOLVER_H