apt-pkg/algorithms.h

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 /* ######################################################################
   4
   5    Algorithms - A set of misc algorithms
   6
   7    This simulate class displays what the ordering code has done and
   8    analyses it with a fresh new dependency cache. In this way we can
   9    see all of the effects of an upgrade run.
  10
  11    pkgDistUpgrade computes an upgrade that causes as many packages as
  12    possible to move to the newest version.
  13
  14    pkgApplyStatus sets the target state based on the content of the status
  15    field in the status file. It is important to get proper crash recovery.
  16
  17    pkgFixBroken corrects a broken system so that it is in a sane state.
  18
  19    pkgAllUpgrade attempts to upgade as many packages as possible but
  20    without installing new packages.
  21
  22    The problem resolver class contains a number of complex algorithms
  23    to try to best-guess an upgrade state. It solves the problem of
  24    maximizing the number of install state packages while having no broken
  25    packages.
  26
  27    ##################################################################### */
  28                                                                         /*}}}*/
  29 #ifndef PKGLIB_ALGORITHMS_H
  30 #define PKGLIB_ALGORITHMS_H
  31
  32
  33 #include <apt-pkg/packagemanager.h>
  34 #include <apt-pkg/depcache.h>
  35 #include <apt-pkg/pkgcache.h>
  36 #include <apt-pkg/cacheiterators.h>
  37
  38 #include <iostream>
  39 #include <string>
  40
  41 #include <apt-pkg/macros.h>
  42
  43 #ifndef APT_8_CLEANER_HEADERS
  44 #include <apt-pkg/acquire.h>
  45 using std::ostream;
  46 #endif
  47
  48 #ifndef APT_9_CLEANER_HEADERS
  49 // include pkg{DistUpgrade,AllUpgrade,MiniizeUpgrade} here for compatibility
  50 #include <apt-pkg/upgrade.h>
  51 #include <apt-pkg/update.h>
  52 #endif
  53
  54
  55 class pkgSimulatePrivate;
  56 class pkgSimulate : public pkgPackageManager                            /*{{{*/
  57 {
  58    pkgSimulatePrivate * const d;
  59    protected:
  60
  61    class Policy : public pkgDepCache::Policy
  62    {
  63       pkgDepCache *Cache;
  64       public:
  65
  66       virtual VerIterator GetCandidateVer(PkgIterator const &Pkg) APT_OVERRIDE
  67       {
  68          return (*Cache)[Pkg].CandidateVerIter(*Cache);
  69       }
  70
  71       explicit Policy(pkgDepCache *Cache) : Cache(Cache) {};
  72    };
  73
  74    unsigned char *Flags;
  75
  76    Policy iPolicy;
  77    pkgDepCache Sim;
  78    pkgDepCache::ActionGroup group;
  79
  80    // The Actual installation implementation
  81    virtual bool Install(PkgIterator Pkg,std::string File) APT_OVERRIDE;
  82    virtual bool Configure(PkgIterator Pkg) APT_OVERRIDE;
  83    virtual bool Remove(PkgIterator Pkg,bool Purge) APT_OVERRIDE;
  84
  85    // FIXME: trick to avoid ABI break for virtual reimplementation; fix on next ABI break
  86 public:
  87    APT_HIDDEN bool Go2(APT::Progress::PackageManager * progress);
  88
  89 private:
  90    APT_HIDDEN void ShortBreaks();
  91    APT_HIDDEN void Describe(PkgIterator iPkg,std::ostream &out,bool Current,bool Candidate);
  92    APT_HIDDEN bool RealInstall(PkgIterator Pkg,std::string File);
  93    APT_HIDDEN bool RealConfigure(PkgIterator Pkg);
  94    APT_HIDDEN bool RealRemove(PkgIterator Pkg,bool Purge);
  95
  96    public:
  97
  98    explicit pkgSimulate(pkgDepCache *Cache);
  99    virtual ~pkgSimulate();
 100 };
 101                                                                         /*}}}*/
 102 class pkgProblemResolver                                                /*{{{*/
 103 {
 104  private:
 105    /** \brief dpointer placeholder (for later in case we need it) */
 106    void * const d;
 107
 108    pkgDepCache &Cache;
 109    typedef pkgCache::PkgIterator PkgIterator;
 110    typedef pkgCache::VerIterator VerIterator;
 111    typedef pkgCache::DepIterator DepIterator;
 112    typedef pkgCache::PrvIterator PrvIterator;
 113    typedef pkgCache::Version Version;
 114    typedef pkgCache::Package Package;
 115
 116    enum Flags {Protected = (1 << 0), PreInstalled = (1 << 1),
 117                Upgradable = (1 << 2), ReInstateTried = (1 << 3),
 118                ToRemove = (1 << 4)};
 119    int *Scores;
 120    unsigned char *Flags;
 121    bool Debug;
 122
 123    // Sort stuff
 124    APT_HIDDEN int ScoreSort(Package const *A, Package const *B) APT_PURE;
 125
 126    struct PackageKill
 127    {
 128       PkgIterator Pkg;
 129       DepIterator Dep;
 130    };
 131
 132    APT_HIDDEN void MakeScores();
 133    APT_HIDDEN bool DoUpgrade(pkgCache::PkgIterator Pkg);
 134
 135    protected:
 136    bool InstOrNewPolicyBroken(pkgCache::PkgIterator Pkg);
 137
 138    public:
 139
 140    inline void Protect(pkgCache::PkgIterator Pkg) {Flags[Pkg->ID] |= Protected; Cache.MarkProtected(Pkg);};
 141    inline void Remove(pkgCache::PkgIterator Pkg) {Flags[Pkg->ID] |= ToRemove;};
 142    inline void Clear(pkgCache::PkgIterator Pkg) {Flags[Pkg->ID] &= ~(Protected | ToRemove);};
 143
 144    // Try to intelligently resolve problems by installing and removing packages
 145    bool Resolve(bool BrokenFix = false, OpProgress * const Progress = NULL);
 146    APT_HIDDEN bool ResolveInternal(bool const BrokenFix = false);
 147
 148    // Try to resolve problems only by using keep
 149    bool ResolveByKeep(OpProgress * const Progress = NULL);
 150    APT_HIDDEN bool ResolveByKeepInternal();
 151
 152    APT_DEPRECATED_MSG("NOOP as MarkInstall enforces not overriding FromUser markings") void InstallProtect();
 153
 154    explicit pkgProblemResolver(pkgDepCache *Cache);
 155    virtual ~pkgProblemResolver();
 156 };
 157                                                                         /*}}}*/
 158 bool pkgApplyStatus(pkgDepCache &Cache);
 159 bool pkgFixBroken(pkgDepCache &Cache);
 160
 161 void pkgPrioSortList(pkgCache &Cache,pkgCache::Version **List);
 162
 163
 164 #endif