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 Install() const {return Mode == ModeInstall;};
 253       inline VerIterator InstVerIter(pkgCache &Cache)
 254                 {return VerIterator(Cache,InstallVer);};
 255       inline VerIterator CandidateVerIter(pkgCache &Cache)
 256                 {return VerIterator(Cache,CandidateVer);};
 257    };
 258
 259    // Helper functions
 260    void BuildGroupOrs(VerIterator const &V);
 261    void UpdateVerState(PkgIterator Pkg);
 262
 263    // User Policy control
 264    class Policy
 265    {
 266       public:
 267
 268       virtual VerIterator GetCandidateVer(PkgIterator Pkg);
 269       virtual bool IsImportantDep(DepIterator Dep);
 270
 271       virtual ~Policy() {};
 272    };
 273
 274    private:
 275    /** The number of open "action groups"; certain post-action
 276     *  operations are suppressed if this number is > 0.
 277     */
 278    int group_level;
 279
 280    friend class ActionGroup;
 281
 282    protected:
 283
 284    // State information
 285    pkgCache *Cache;
 286    StateCache *PkgState;
 287    unsigned char *DepState;
 288
 289    double iUsrSize;
 290    double iDownloadSize;
 291    unsigned long iInstCount;
 292    unsigned long iDelCount;
 293    unsigned long iKeepCount;
 294    unsigned long iBrokenCount;
 295    unsigned long iBadCount;
 296
 297    Policy *delLocalPolicy;           // For memory clean up..
 298    Policy *LocalPolicy;
 299
 300    // Check for a matching provides
 301    bool CheckDep(DepIterator Dep,int Type,PkgIterator &Res);
 302    inline bool CheckDep(DepIterator Dep,int Type)
 303    {
 304       PkgIterator Res(*this,0);
 305       return CheckDep(Dep,Type,Res);
 306    }
 307
 308    // Computes state information for deps and versions (w/o storing)
 309    unsigned char DependencyState(DepIterator &D);
 310    unsigned char VersionState(DepIterator D,unsigned char Check,
 311                               unsigned char SetMin,
 312                               unsigned char SetPolicy);
 313
 314    // Recalculates various portions of the cache, call after changing something
 315    void Update(DepIterator Dep);           // Mostly internal
 316    void Update(PkgIterator const &P);
 317
 318    // Count manipulators
 319    void AddSizes(const PkgIterator &Pkg,signed long Mult = 1);
 320    inline void RemoveSizes(const PkgIterator &Pkg) {AddSizes(Pkg,-1);};
 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 PkgIterator PkgBegin() {return Cache->PkgBegin();};
 330    inline PkgIterator FindPkg(string const &Name) {return Cache->FindPkg(Name);};
 331
 332    inline pkgCache &GetCache() {return *Cache;};
 333    inline pkgVersioningSystem &VS() {return *Cache->VS;};
 334
 335    // Policy implementation
 336    inline VerIterator GetCandidateVer(PkgIterator Pkg) {return LocalPolicy->GetCandidateVer(Pkg);};
 337    inline bool IsImportantDep(DepIterator Dep) {return LocalPolicy->IsImportantDep(Dep);};
 338    inline Policy &GetPolicy() {return *LocalPolicy;};
 339
 340    // Accessors
 341    inline StateCache &operator [](PkgIterator const &I) {return PkgState[I->ID];};
 342    inline unsigned char &operator [](DepIterator const &I) {return DepState[I->ID];};
 343
 344    /** \return A function identifying packages in the root set other
 345     *  than manually installed packages and essential packages, or \b
 346     *  NULL if an error occurs.
 347     *
 348     *  \todo Is this the best place for this function?  Perhaps the
 349     *  settings for mark-and-sweep should be stored in a single
 350     *  external class?
 351     */
 352    virtual InRootSetFunc *GetRootSetFunc();
 353
 354    /** \return \b true if the garbage collector should follow recommendations.
 355     */
 356    virtual bool MarkFollowsRecommends();
 357
 358    /** \return \b true if the garbage collector should follow suggestions.
 359     */
 360    virtual bool MarkFollowsSuggests();
 361
 362    /** \brief Update the Marked and Garbage fields of all packages.
 363     *
 364     *  This routine is implicitly invoked after all state manipulators
 365     *  and when an ActionGroup is destroyed.  It invokes #MarkRequired
 366     *  and #Sweep to do its dirty work.
 367     *
 368     *  \param rootFunc A predicate that returns \b true for packages
 369     *  that should be added to the root set.
 370     */
 371    bool MarkAndSweep(InRootSetFunc &rootFunc)
 372    {
 373      return MarkRequired(rootFunc) && Sweep();
 374    }
 375
 376    bool MarkAndSweep()
 377    {
 378      std::auto_ptr<InRootSetFunc> f(GetRootSetFunc());
 379      if(f.get() != NULL)
 380        return MarkAndSweep(*f.get());
 381      else
 382        return false;
 383    }
 384
 385    /** \name State Manipulators
 386     */
 387    // @{
 388    void MarkKeep(PkgIterator const &Pkg, bool Soft = false,
 389                  bool FromUser = true);
 390    void MarkDelete(PkgIterator const &Pkg,bool Purge = false);
 391    void MarkInstall(PkgIterator const &Pkg,bool AutoInst = true,
 392                     unsigned long Depth = 0, bool FromUser = true);
 393    void SetReInstall(PkgIterator const &Pkg,bool To);
 394    void SetCandidateVersion(VerIterator TargetVer);
 395
 396    /** Set the "is automatically installed" flag of Pkg. */
 397    void MarkAuto(const PkgIterator &Pkg, bool Auto);
 398    // @}
 399
 400    // This is for debuging
 401    void Update(OpProgress *Prog = 0);
 402
 403    // read persistent states
 404    bool readStateFile(OpProgress *prog);
 405    bool writeStateFile(OpProgress *prog);
 406
 407    // Size queries
 408    inline double UsrSize() {return iUsrSize;};
 409    inline double DebSize() {return iDownloadSize;};
 410    inline unsigned long DelCount() {return iDelCount;};
 411    inline unsigned long KeepCount() {return iKeepCount;};
 412    inline unsigned long InstCount() {return iInstCount;};
 413    inline unsigned long BrokenCount() {return iBrokenCount;};
 414    inline unsigned long BadCount() {return iBadCount;};
 415
 416    bool Init(OpProgress *Prog);
 417
 418    pkgDepCache(pkgCache *Cache,Policy *Plcy = 0);
 419    virtual ~pkgDepCache();
 420 };
 421
 422 #endif