apt-pkg/depcache.h

   1 // -*- mode: c++; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 /* ######################################################################
   4
   5    DepCache - Dependency Extension data for the cache
   6
   7    This class stores the cache data and a set of extension structures for
   8    monitoring the current state of all the packages. It also generates and
   9    caches the 'install' state of many things. This refers to the state of the
  10    package after an install has been run.
  11
  12    The StateCache::State field can be -1,0,1,2 which is <,=,>,no current.
  13    StateCache::Mode is which of the 3 fields is active.
  14
  15    This structure is important to support the readonly status of the cache
  16    file. When the data is saved the cache will be refereshed from our
  17    internal rep and written to disk. Then the actual persistent data
  18    files will be put on the disk.
  19
  20    Each dependency is compared against 3 target versions to produce to
  21    3 dependency results.
  22      Now - Compared using the Currently install version
  23      Install - Compared using the install version (final state)
  24      CVer - (Candidate Verion) Compared using the Candidate Version
  25    The candidate and now results are used to decide wheather a package
  26    should be automatically installed or if it should be left alone.
  27
  28    Remember, the Candidate Version is selected based on the distribution
  29    settings for the Package. The Install Version is selected based on the
  30    state (Delete, Keep, Install) field and can be either the Current Version
  31    or the Candidate version.
  32
  33    The Candidate version is what is shown the 'Install Version' field.
  34
  35    ##################################################################### */
  36                                                                         /*}}}*/
  37 #ifndef PKGLIB_DEPCACHE_H
  38 #define PKGLIB_DEPCACHE_H
  39
  40 #include <apt-pkg/configuration.h>
  41 #include <apt-pkg/pkgcache.h>
  42 #include <apt-pkg/cacheiterators.h>
  43 #include <apt-pkg/macros.h>
  44
  45 #include <stddef.h>
  46
  47 #include <memory>
  48 #include <list>
  49 #include <string>
  50 #include <utility>
  51
  52 #ifndef APT_8_CLEANER_HEADERS
  53 #include <apt-pkg/progress.h>
  54 #include <apt-pkg/error.h>
  55 #endif
  56 #ifndef APT_10_CLEANER_HEADERS
  57 #include <set>
  58 #include <vector>
  59 #endif
  60
  61 class OpProgress;
  62 class pkgVersioningSystem;
  63
  64 class pkgDepCache : protected pkgCache::Namespace
  65 {
  66    public:
  67
  68    /** \brief An arbitrary predicate on packages. */
  69    class InRootSetFunc
  70    {
  71    public:
  72      virtual bool InRootSet(const pkgCache::PkgIterator &/*pkg*/) {return false;};
  73      virtual ~InRootSetFunc() {};
  74    };
  75
  76    private:
  77    /** \brief Mark a single package and all its unmarked important
  78     *  dependencies during mark-and-sweep.
  79     *
  80     *  Recursively invokes itself to mark all dependencies of the
  81     *  package.
  82     *
  83     *  \param pkg The package to mark.
  84     *
  85     *  \param ver The version of the package that is to be marked.
  86     *
  87     *  \param follow_recommends If \b true, recommendations of the
  88     *  package will be recursively marked.
  89     *
  90     *  \param follow_suggests If \b true, suggestions of the package
  91     *  will be recursively marked.
  92     */
  93    APT_HIDDEN void MarkPackage(const pkgCache::PkgIterator &pkg,
  94                     const pkgCache::VerIterator &ver,
  95                     bool const &follow_recommends,
  96                     bool const &follow_suggests);
  97
  98    /** \brief Update the Marked field of all packages.
  99     *
 100     *  Each package's StateCache::Marked field will be set to \b true
 101     *  if and only if it can be reached from the root set.  By
 102     *  default, the root set consists of the set of manually installed
 103     *  or essential packages, but it can be extended using the
 104     *  parameter #rootFunc.
 105     *
 106     *  \param rootFunc A callback that can be used to add extra
 107     *  packages to the root set.
 108     *
 109     *  \return \b false if an error occurred.
 110     */
 111    bool MarkRequired(InRootSetFunc &rootFunc);
 112
 113    /** \brief Set the StateCache::Garbage flag on all packages that
 114     *  should be removed.
 115     *
 116     *  Packages that were not marked by the last call to #MarkRequired
 117     *  are tested to see whether they are actually garbage.  If so,
 118     *  they are marked as such.
 119     *
 120     *  \return \b false if an error occurred.
 121     */
 122    bool Sweep();
 123
 124    public:
 125
 126    // These flags are used in DepState
 127    enum DepFlags {DepNow = (1 << 0),DepInstall = (1 << 1),DepCVer = (1 << 2),
 128                   DepGNow = (1 << 3),DepGInstall = (1 << 4),DepGCVer = (1 << 5)};
 129
 130    // These flags are used in StateCache::DepState
 131    enum DepStateFlags {DepNowPolicy = (1 << 0), DepNowMin = (1 << 1),
 132                        DepInstPolicy = (1 << 2), DepInstMin = (1 << 3),
 133                        DepCandPolicy = (1 << 4), DepCandMin = (1 << 5)};
 134
 135    // These flags are used in StateCache::iFlags
 136    enum InternalFlags {AutoKept = (1 << 0), Purge = (1 << 1), ReInstall = (1 << 2), Protected = (1 << 3)};
 137
 138    enum VersionTypes {NowVersion, InstallVersion, CandidateVersion};
 139    enum ModeList {ModeDelete = 0, ModeKeep = 1, ModeInstall = 2, ModeGarbage = 3};
 140
 141    /** \brief Represents an active action group.
 142     *
 143     *  An action group is a group of actions that are currently being
 144     *  performed.  While an active group is active, certain routine
 145     *  clean-up actions that would normally be performed after every
 146     *  cache operation are delayed until the action group is
 147     *  completed.  This is necessary primarily to avoid inefficiencies
 148     *  when modifying a large number of packages at once.
 149     *
 150     *  This class represents an active action group.  Creating an
 151     *  instance will create an action group; destroying one will
 152     *  destroy the corresponding action group.
 153     *
 154     *  The following operations are suppressed by this class:
 155     *
 156     *    - Keeping the Marked and Garbage flags up to date.
 157     *
 158     *  \note This can be used in the future to easily accumulate
 159     *  atomic actions for undo or to display "what apt did anyway";
 160     *  e.g., change the counter of how many action groups are active
 161     *  to a std::set of pointers to them and use those to store
 162     *  information about what happened in a group in the group.
 163     */
 164    class ActionGroup
 165    {
 166        void * const d;
 167        pkgDepCache &cache;
 168
 169        bool released;
 170
 171        /** Action groups are noncopyable. */
 172        APT_HIDDEN ActionGroup(const ActionGroup &other);
 173    public:
 174        /** \brief Create a new ActionGroup.
 175         *
 176         *  \param cache The cache that this ActionGroup should
 177         *  manipulate.
 178         *
 179         *  As long as this object exists, no automatic cleanup
 180         *  operations will be undertaken.
 181         */
 182        explicit ActionGroup(pkgDepCache &cache);
 183
 184        /** \brief Clean up the action group before it is destroyed.
 185         *
 186         *  If it is destroyed later, no second cleanup wil be run.
 187         */
 188        void release();
 189
 190        /** \brief Destroy the action group.
 191         *
 192         *  If this is the last action group, the automatic cache
 193         *  cleanup operations will be undertaken.
 194         */
 195        virtual ~ActionGroup();
 196    };
 197
 198    /** \brief Returns \b true for packages matching a regular
 199     *  expression in APT::NeverAutoRemove.
 200     */
 201    class DefaultRootSetFunc : public InRootSetFunc, public Configuration::MatchAgainstConfig
 202    {
 203    public:
 204      DefaultRootSetFunc() : Configuration::MatchAgainstConfig("APT::NeverAutoRemove") {};
 205      virtual ~DefaultRootSetFunc() {};
 206
 207      bool InRootSet(const pkgCache::PkgIterator &pkg) APT_OVERRIDE { return pkg.end() == false && Match(pkg.Name()); };
 208    };
 209
 210    struct StateCache
 211    {
 212       // text versions of the two version fields
 213       const char *CandVersion;
 214       const char *CurVersion;
 215
 216       // Pointer to the candidate install version.
 217       Version *CandidateVer;
 218
 219       // Pointer to the install version.
 220       Version *InstallVer;
 221
 222       // Copy of Package::Flags
 223       unsigned short Flags;
 224       unsigned short iFlags;           // Internal flags
 225
 226       /** \brief \b true if this package can be reached from the root set. */
 227       bool Marked;
 228
 229       /** \brief \b true if this package is unused and should be removed.
 230        *
 231        *  This differs from !#Marked, because it is possible that some
 232        *  unreachable packages will be protected from becoming
 233        *  garbage.
 234        */
 235       bool Garbage;
 236
 237       // Various tree indicators
 238       signed char Status;              // -1,0,1,2
 239       unsigned char Mode;              // ModeList
 240       unsigned char DepState;          // DepState Flags
 241
 242       // Update of candidate version
 243       APT_DEPRECATED_MSG("Use the method of the same name in contrib/strutl.h instead if you must") const char *StripEpoch(const char *Ver) APT_PURE;
 244       void Update(PkgIterator Pkg,pkgCache &Cache);
 245
 246       // Various test members for the current status of the package
 247       inline bool NewInstall() const {return Status == 2 && Mode == ModeInstall;};
 248       inline bool Delete() const {return Mode == ModeDelete;};
 249       inline bool Purge() const {return Delete() == true && (iFlags & pkgDepCache::Purge) == pkgDepCache::Purge; };
 250       inline bool Keep() const {return Mode == ModeKeep;};
 251       inline bool Protect() const {return (iFlags & Protected) == Protected;};
 252       inline bool Upgrade() const {return Status > 0 && Mode == ModeInstall;};
 253       inline bool Upgradable() const {return Status >= 1 && CandidateVer != NULL;};
 254       inline bool Downgrade() const {return Status < 0 && Mode == ModeInstall;};
 255       inline bool Held() const {return Status != 0 && Keep();};
 256       inline bool NowBroken() const {return (DepState & DepNowMin) != DepNowMin;};
 257       inline bool NowPolicyBroken() const {return (DepState & DepNowPolicy) != DepNowPolicy;};
 258       inline bool InstBroken() const {return (DepState & DepInstMin) != DepInstMin;};
 259       inline bool InstPolicyBroken() const {return (DepState & DepInstPolicy) != DepInstPolicy;};
 260       inline bool Install() const {return Mode == ModeInstall;};
 261       inline bool ReInstall() const {return Delete() == false && (iFlags & pkgDepCache::ReInstall) == pkgDepCache::ReInstall;};
 262       inline VerIterator InstVerIter(pkgCache &Cache)
 263                 {return VerIterator(Cache,InstallVer);};
 264       inline VerIterator CandidateVerIter(pkgCache &Cache)
 265                 {return VerIterator(Cache,CandidateVer);};
 266    };
 267
 268    // Helper functions
 269    void BuildGroupOrs(VerIterator const &V);
 270    void UpdateVerState(PkgIterator const &Pkg);
 271
 272    // User Policy control
 273    class Policy
 274    {
 275       public:
 276       Policy() {
 277          InstallRecommends = _config->FindB("APT::Install-Recommends", false);
 278          InstallSuggests = _config->FindB("APT::Install-Suggests", false);
 279       }
 280
 281       virtual VerIterator GetCandidateVer(PkgIterator const &Pkg);
 282       virtual bool IsImportantDep(DepIterator const &Dep) const;
 283       virtual signed short GetPriority(PkgIterator const &Pkg);
 284       virtual signed short GetPriority(VerIterator const &Ver, bool ConsiderFiles=true);
 285       virtual signed short GetPriority(PkgFileIterator const &File);
 286
 287       virtual ~Policy() {};
 288
 289       private:
 290       bool InstallRecommends;
 291       bool InstallSuggests;
 292    };
 293
 294    private:
 295    /** The number of open "action groups"; certain post-action
 296     *  operations are suppressed if this number is > 0.
 297     */
 298    int group_level;
 299
 300    friend class ActionGroup;
 301
 302    protected:
 303
 304    // State information
 305    pkgCache *Cache;
 306    StateCache *PkgState;
 307    unsigned char *DepState;
 308
 309    /** Stores the space changes after installation */
 310    signed long long iUsrSize;
 311    /** Stores how much we need to download to get the packages */
 312    unsigned long long iDownloadSize;
 313    unsigned long iInstCount;
 314    unsigned long iDelCount;
 315    unsigned long iKeepCount;
 316    unsigned long iBrokenCount;
 317    unsigned long iPolicyBrokenCount;
 318    unsigned long iBadCount;
 319
 320    bool DebugMarker;
 321    bool DebugAutoInstall;
 322
 323    Policy *delLocalPolicy;           // For memory clean up..
 324    Policy *LocalPolicy;
 325
 326    // Check for a matching provides
 327    bool CheckDep(DepIterator const &Dep,int const Type,PkgIterator &Res);
 328    inline bool CheckDep(DepIterator const &Dep,int const Type)
 329    {
 330       PkgIterator Res(*this,0);
 331       return CheckDep(Dep,Type,Res);
 332    }
 333
 334    // Computes state information for deps and versions (w/o storing)
 335    unsigned char DependencyState(DepIterator const &D);
 336    unsigned char VersionState(DepIterator D,unsigned char const Check,
 337                               unsigned char const SetMin,
 338                               unsigned char const SetPolicy) const;
 339
 340    // Recalculates various portions of the cache, call after changing something
 341    void Update(DepIterator Dep);           // Mostly internal
 342    void Update(PkgIterator const &P);
 343
 344    // Count manipulators
 345    void AddSizes(const PkgIterator &Pkg, bool const Invert = false);
 346    inline void RemoveSizes(const PkgIterator &Pkg) {AddSizes(Pkg, true);};
 347    void AddStates(const PkgIterator &Pkg, bool const Invert = false);
 348    inline void RemoveStates(const PkgIterator &Pkg) {AddStates(Pkg,true);};
 349
 350    public:
 351
 352    // Legacy.. We look like a pkgCache
 353    inline operator pkgCache &() {return *Cache;};
 354    inline Header &Head() {return *Cache->HeaderP;};
 355    inline GrpIterator GrpBegin() {return Cache->GrpBegin();};
 356    inline PkgIterator PkgBegin() {return Cache->PkgBegin();};
 357    inline GrpIterator FindGrp(std::string const &Name) {return Cache->FindGrp(Name);};
 358    inline PkgIterator FindPkg(std::string const &Name) {return Cache->FindPkg(Name);};
 359    inline PkgIterator FindPkg(std::string const &Name, std::string const &Arch) {return Cache->FindPkg(Name, Arch);};
 360
 361    inline pkgCache &GetCache() {return *Cache;};
 362    inline pkgVersioningSystem &VS() {return *Cache->VS;};
 363
 364    // Policy implementation
 365    APT_DEPRECATED_MSG("Confusingly named method which returns the candidate as chosen by policy (NOT as chosen via .SetCandidateVersion!). You probably want to use .GetCandidateVersion instead.") inline VerIterator GetCandidateVer(PkgIterator const &Pkg) {return /* GetCandidateVersion(Pkg); but for API compat: */ LocalPolicy->GetCandidateVer(Pkg);};
 366
 367    inline bool IsImportantDep(DepIterator Dep) const {return LocalPolicy->IsImportantDep(Dep);};
 368    inline Policy &GetPolicy() {return *LocalPolicy;};
 369
 370    // Accessors
 371    inline StateCache &operator [](PkgIterator const &I) {return PkgState[I->ID];};
 372    inline StateCache &operator [](PkgIterator const &I) const {return PkgState[I->ID];};
 373    inline unsigned char &operator [](DepIterator const &I) {return DepState[I->ID];};
 374
 375    /** \return A function identifying packages in the root set other
 376     *  than manually installed packages and essential packages, or \b
 377     *  NULL if an error occurs.
 378     *
 379     *  \todo Is this the best place for this function?  Perhaps the
 380     *  settings for mark-and-sweep should be stored in a single
 381     *  external class?
 382     */
 383    virtual InRootSetFunc *GetRootSetFunc();
 384
 385    /** \return \b true if the garbage collector should follow recommendations.
 386     */
 387    virtual bool MarkFollowsRecommends();
 388
 389    /** \return \b true if the garbage collector should follow suggestions.
 390     */
 391    virtual bool MarkFollowsSuggests();
 392
 393    /** \brief Update the Marked and Garbage fields of all packages.
 394     *
 395     *  This routine is implicitly invoked after all state manipulators
 396     *  and when an ActionGroup is destroyed.  It invokes the private
 397     *  MarkRequired() and Sweep() to do its dirty work.
 398     *
 399     *  \param rootFunc A predicate that returns \b true for packages
 400     *  that should be added to the root set.
 401     */
 402    bool MarkAndSweep(InRootSetFunc &rootFunc);
 403    bool MarkAndSweep();
 404
 405    /** \name State Manipulators
 406     */
 407    // @{
 408    bool MarkKeep(PkgIterator const &Pkg, bool Soft = false,
 409                  bool FromUser = true, unsigned long Depth = 0);
 410    bool MarkDelete(PkgIterator const &Pkg, bool MarkPurge = false,
 411                    unsigned long Depth = 0, bool FromUser = true);
 412    bool MarkInstall(PkgIterator const &Pkg,bool AutoInst = true,
 413                     unsigned long Depth = 0, bool FromUser = true,
 414                     bool ForceImportantDeps = false);
 415    void MarkProtected(PkgIterator const &Pkg) { PkgState[Pkg->ID].iFlags |= Protected; };
 416
 417    void SetReInstall(PkgIterator const &Pkg,bool To);
 418
 419    /** @return 'the' candidate version of a package
 420     *
 421     * The version returned is the version previously set explicitly via
 422     * SetCandidate* methods like #SetCandidateVersion or if there wasn't one
 423     * set the version as chosen via #Policy.
 424     *
 425     * @param Pkg is the package to return the candidate for
 426     */
 427    pkgCache::VerIterator GetCandidateVersion(pkgCache::PkgIterator const &Pkg);
 428    void SetCandidateVersion(VerIterator TargetVer);
 429    bool SetCandidateRelease(pkgCache::VerIterator TargetVer,
 430                                 std::string const &TargetRel);
 431    /** Set the candidate version for dependencies too if needed.
 432     *
 433     *  Sets not only the candidate version as SetCandidateVersion does,
 434     *  but walks also down the dependency tree and checks if it is required
 435     *  to set the candidate of the dependency to a version from the given
 436     *  release, too.
 437     *
 438     *  \param TargetVer new candidate version of the package
 439     *  \param TargetRel try to switch to this release if needed
 440     *  \param[out] Changed a list of pairs consisting of the \b old
 441     *              version of the changed package and the version which
 442     *              required the switch of this dependency
 443     *  \return \b true if the switch was successful, \b false otherwise
 444     */
 445    bool SetCandidateRelease(pkgCache::VerIterator TargetVer,
 446                             std::string const &TargetRel,
 447                             std::list<std::pair<pkgCache::VerIterator, pkgCache::VerIterator> > &Changed);
 448
 449    /** Set the "is automatically installed" flag of Pkg. */
 450    void MarkAuto(const PkgIterator &Pkg, bool Auto);
 451    // @}
 452
 453    /** \return \b true if it's OK for MarkInstall to install
 454     *  the given package.
 455     *
 456     *  The default implementation simply calls all IsInstallOk*
 457     *  method mentioned below.
 458     *
 459     *  Overriding implementations should use the hold-state-flag to
 460     *  cache results from previous checks of this package - if possible.
 461     *
 462     *  The parameters are the same as in the calling MarkInstall:
 463     *  \param Pkg       the package that MarkInstall wants to install.
 464     *  \param AutoInst  install this and all its dependencies
 465     *  \param Depth     recursive deep of this Marker call
 466     *  \param FromUser  was the install requested by the user?
 467     */
 468    virtual bool IsInstallOk(const PkgIterator &Pkg,bool AutoInst = true,
 469                             unsigned long Depth = 0, bool FromUser = true);
 470
 471    /** \return \b true if it's OK for MarkDelete to remove
 472     *  the given package.
 473     *
 474     *  The default implementation simply calls all IsDeleteOk*
 475     *  method mentioned below, see also #IsInstallOk.
 476     *
 477     *  The parameters are the same as in the calling MarkDelete:
 478     *  \param Pkg       the package that MarkDelete wants to remove.
 479     *  \param MarkPurge should we purge instead of "only" remove?
 480     *  \param Depth     recursive deep of this Marker call
 481     *  \param FromUser  was the remove requested by the user?
 482     */
 483    virtual bool IsDeleteOk(const PkgIterator &Pkg,bool MarkPurge = false,
 484                             unsigned long Depth = 0, bool FromUser = true);
 485
 486    // read persistent states
 487    bool readStateFile(OpProgress * const prog);
 488    bool writeStateFile(OpProgress * const prog, bool const InstalledOnly=true);
 489
 490    // Size queries
 491    inline signed long long UsrSize() {return iUsrSize;};
 492    inline unsigned long long DebSize() {return iDownloadSize;};
 493    inline unsigned long DelCount() {return iDelCount;};
 494    inline unsigned long KeepCount() {return iKeepCount;};
 495    inline unsigned long InstCount() {return iInstCount;};
 496    inline unsigned long BrokenCount() {return iBrokenCount;};
 497    inline unsigned long PolicyBrokenCount() {return iPolicyBrokenCount;};
 498    inline unsigned long BadCount() {return iBadCount;};
 499
 500    bool Init(OpProgress * const Prog);
 501    // Generate all state information
 502    void Update(OpProgress * const Prog = 0);
 503
 504    pkgDepCache(pkgCache * const Cache,Policy * const Plcy = 0);
 505    virtual ~pkgDepCache();
 506
 507    protected:
 508    // methods call by IsInstallOk
 509    bool IsInstallOkMultiArchSameVersionSynced(PkgIterator const &Pkg,
 510          bool const AutoInst, unsigned long const Depth, bool const FromUser);
 511    bool IsInstallOkDependenciesSatisfiableByCandidates(PkgIterator const &Pkg,
 512       bool const AutoInst, unsigned long const Depth, bool const FromUser);
 513
 514    // methods call by IsDeleteOk
 515    bool IsDeleteOkProtectInstallRequests(PkgIterator const &Pkg,
 516          bool const rPurge, unsigned long const Depth, bool const FromUser);
 517
 518    private:
 519    void * const d;
 520
 521    APT_HIDDEN bool IsModeChangeOk(ModeList const mode, PkgIterator const &Pkg,
 522                         unsigned long const Depth, bool const FromUser);
 523 };
 524
 525 #endif