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