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