apt-pkg/depcache.h

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