apt  0.9.12.1
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 
44 #include <vector>
45 #include <memory>
46 #include <set>
47 #include <list>
48 
49 #ifndef APT_8_CLEANER_HEADERS
50 #include <apt-pkg/progress.h>
51 #include <apt-pkg/error.h>
52 #endif
53 
54 class OpProgress;
55 
57 {
58  public:
59 
62  {
63  public:
64  virtual bool InRootSet(const pkgCache::PkgIterator &pkg) {return false;};
65  virtual ~InRootSetFunc() {};
66  };
67 
68  private:
85  void MarkPackage(const pkgCache::PkgIterator &pkg,
86  const pkgCache::VerIterator &ver,
87  bool const &follow_recommends,
88  bool const &follow_suggests);
89 
103  bool MarkRequired(InRootSetFunc &rootFunc);
104 
114  bool Sweep();
115 
116  public:
117 
118  // These flags are used in DepState
119  enum DepFlags {DepNow = (1 << 0),DepInstall = (1 << 1),DepCVer = (1 << 2),
120  DepGNow = (1 << 3),DepGInstall = (1 << 4),DepGCVer = (1 << 5)};
121 
122  // These flags are used in StateCache::DepState
123  enum DepStateFlags {DepNowPolicy = (1 << 0), DepNowMin = (1 << 1),
124  DepInstPolicy = (1 << 2), DepInstMin = (1 << 3),
125  DepCandPolicy = (1 << 4), DepCandMin = (1 << 5)};
126 
127  // These flags are used in StateCache::iFlags
128  enum InternalFlags {AutoKept = (1 << 0), Purge = (1 << 1), ReInstall = (1 << 2), Protected = (1 << 3)};
129 
130  enum VersionTypes {NowVersion, InstallVersion, CandidateVersion};
131  enum ModeList {ModeDelete = 0, ModeKeep = 1, ModeInstall = 2, ModeGarbage = 3};
132 
157  {
158  pkgDepCache &cache;
159 
160  bool released;
161 
163  ActionGroup(const ActionGroup &other);
164  public:
173  ActionGroup(pkgDepCache &cache);
174 
179  void release();
180 
186  ~ActionGroup();
187  };
188 
193  {
194  public:
195  DefaultRootSetFunc() : Configuration::MatchAgainstConfig("APT::NeverAutoRemove") {};
196  virtual ~DefaultRootSetFunc() {};
197 
198  bool InRootSet(const pkgCache::PkgIterator &pkg) { return pkg.end() == false && Match(pkg.Name()); };
199  };
200 
201  struct StateCache
202  {
203  // Epoch stripped text versions of the two version fields
204  const char *CandVersion;
205  const char *CurVersion;
206 
207  // Pointer to the candidate install version.
208  Version *CandidateVer;
209 
210  // Pointer to the install version.
211  Version *InstallVer;
212 
213  // Copy of Package::Flags
214  unsigned short Flags;
215  unsigned short iFlags; // Internal flags
216 
218  bool Marked;
219 
226  bool Garbage;
227 
228  // Various tree indicators
229  signed char Status; // -1,0,1,2
230  unsigned char Mode; // ModeList
231  unsigned char DepState; // DepState Flags
232 
233  // Update of candidate version
234  const char *StripEpoch(const char *Ver);
235  void Update(PkgIterator Pkg,pkgCache &Cache);
236 
237  // Various test members for the current status of the package
238  inline bool NewInstall() const {return Status == 2 && Mode == ModeInstall;};
239  inline bool Delete() const {return Mode == ModeDelete;};
240  inline bool Purge() const {return Delete() == true && (iFlags & pkgDepCache::Purge) == pkgDepCache::Purge; };
241  inline bool Keep() const {return Mode == ModeKeep;};
242  inline bool Protect() const {return (iFlags & Protected) == Protected;};
243  inline bool Upgrade() const {return Status > 0 && Mode == ModeInstall;};
244  inline bool Upgradable() const {return Status >= 1;};
245  inline bool Downgrade() const {return Status < 0 && Mode == ModeInstall;};
246  inline bool Held() const {return Status != 0 && Keep();};
247  inline bool NowBroken() const {return (DepState & DepNowMin) != DepNowMin;};
248  inline bool NowPolicyBroken() const {return (DepState & DepNowPolicy) != DepNowPolicy;};
249  inline bool InstBroken() const {return (DepState & DepInstMin) != DepInstMin;};
250  inline bool InstPolicyBroken() const {return (DepState & DepInstPolicy) != DepInstPolicy;};
251  inline bool Install() const {return Mode == ModeInstall;};
252  inline bool ReInstall() const {return Delete() == false && (iFlags & pkgDepCache::ReInstall) == pkgDepCache::ReInstall;};
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  Policy() {
268  InstallRecommends = _config->FindB("APT::Install-Recommends", false);
269  InstallSuggests = _config->FindB("APT::Install-Suggests", false);
270  }
271 
272  virtual VerIterator GetCandidateVer(PkgIterator const &Pkg);
273  virtual bool IsImportantDep(DepIterator const &Dep);
274  virtual signed short GetPriority(PkgIterator const &Pkg);
275  virtual signed short GetPriority(PkgFileIterator const &File);
276 
277  virtual ~Policy() {};
278 
279  private:
280  bool InstallRecommends;
281  bool InstallSuggests;
282  };
283 
284  private:
288  int group_level;
289 
290  friend class ActionGroup;
291 
292  protected:
293 
294  // State information
295  pkgCache *Cache;
296  StateCache *PkgState;
297  unsigned char *DepState;
298 
300  signed long long iUsrSize;
302  unsigned long long iDownloadSize;
303  unsigned long iInstCount;
304  unsigned long iDelCount;
305  unsigned long iKeepCount;
306  unsigned long iBrokenCount;
307  unsigned long iPolicyBrokenCount;
308  unsigned long iBadCount;
309 
310  bool DebugMarker;
311  bool DebugAutoInstall;
312 
313  Policy *delLocalPolicy; // For memory clean up..
314  Policy *LocalPolicy;
315 
316  // Check for a matching provides
317  bool CheckDep(DepIterator Dep,int Type,PkgIterator &Res);
318  inline bool CheckDep(DepIterator Dep,int Type)
319  {
320  PkgIterator Res(*this,0);
321  return CheckDep(Dep,Type,Res);
322  }
323 
324  // Computes state information for deps and versions (w/o storing)
325  unsigned char DependencyState(DepIterator &D);
326  unsigned char VersionState(DepIterator D,unsigned char Check,
327  unsigned char SetMin,
328  unsigned char SetPolicy);
329 
330  // Recalculates various portions of the cache, call after changing something
331  void Update(DepIterator Dep); // Mostly internal
332  void Update(PkgIterator const &P);
333 
334  // Count manipulators
335  void AddSizes(const PkgIterator &Pkg, bool const Invert = false);
336  inline void RemoveSizes(const PkgIterator &Pkg) {AddSizes(Pkg, true);};
337  void AddStates(const PkgIterator &Pkg, bool const Invert = false);
338  inline void RemoveStates(const PkgIterator &Pkg) {AddStates(Pkg,true);};
339 
340  public:
341 
342  // Legacy.. We look like a pkgCache
343  inline operator pkgCache &() {return *Cache;};
344  inline Header &Head() {return *Cache->HeaderP;};
345  inline GrpIterator GrpBegin() {return Cache->GrpBegin();};
346  inline PkgIterator PkgBegin() {return Cache->PkgBegin();};
347  inline GrpIterator FindGrp(std::string const &Name) {return Cache->FindGrp(Name);};
348  inline PkgIterator FindPkg(std::string const &Name) {return Cache->FindPkg(Name);};
349  inline PkgIterator FindPkg(std::string const &Name, std::string const &Arch) {return Cache->FindPkg(Name, Arch);};
350 
351  inline pkgCache &GetCache() {return *Cache;};
352  inline pkgVersioningSystem &VS() {return *Cache->VS;};
353 
354  // Policy implementation
355  inline VerIterator GetCandidateVer(PkgIterator const &Pkg) {return LocalPolicy->GetCandidateVer(Pkg);};
356  inline bool IsImportantDep(DepIterator Dep) {return LocalPolicy->IsImportantDep(Dep);};
357  inline Policy &GetPolicy() {return *LocalPolicy;};
358 
359  // Accessors
360  inline StateCache &operator [](PkgIterator const &I) {return PkgState[I->ID];};
361  inline unsigned char &operator [](DepIterator const &I) {return DepState[I->ID];};
362 
371  virtual InRootSetFunc *GetRootSetFunc();
372 
375  virtual bool MarkFollowsRecommends();
376 
379  virtual bool MarkFollowsSuggests();
380 
390  bool MarkAndSweep(InRootSetFunc &rootFunc)
391  {
392  return MarkRequired(rootFunc) && Sweep();
393  }
394 
395  bool MarkAndSweep()
396  {
397  std::auto_ptr<InRootSetFunc> f(GetRootSetFunc());
398  if(f.get() != NULL)
399  return MarkAndSweep(*f.get());
400  else
401  return false;
402  }
403 
406  // @{
407  bool MarkKeep(PkgIterator const &Pkg, bool Soft = false,
408  bool FromUser = true, unsigned long Depth = 0);
409  bool MarkDelete(PkgIterator const &Pkg, bool MarkPurge = false,
410  unsigned long Depth = 0, bool FromUser = true);
411  bool MarkInstall(PkgIterator const &Pkg,bool AutoInst = true,
412  unsigned long Depth = 0, bool FromUser = true,
413  bool ForceImportantDeps = false);
414  void MarkProtected(PkgIterator const &Pkg) { PkgState[Pkg->ID].iFlags |= Protected; };
415 
416  void SetReInstall(PkgIterator const &Pkg,bool To);
417  void SetCandidateVersion(VerIterator TargetVer);
418  bool SetCandidateRelease(pkgCache::VerIterator TargetVer,
419  std::string const &TargetRel);
434  bool SetCandidateRelease(pkgCache::VerIterator TargetVer,
435  std::string const &TargetRel,
436  std::list<std::pair<pkgCache::VerIterator, pkgCache::VerIterator> > &Changed);
437 
439  void MarkAuto(const PkgIterator &Pkg, bool Auto);
440  // @}
441 
457  virtual bool IsInstallOk(const PkgIterator &Pkg,bool AutoInst = true,
458  unsigned long Depth = 0, bool FromUser = true);
459 
472  virtual bool IsDeleteOk(const PkgIterator &Pkg,bool MarkPurge = false,
473  unsigned long Depth = 0, bool FromUser = true);
474 
475  // read persistent states
476  bool readStateFile(OpProgress *prog);
477  bool writeStateFile(OpProgress *prog, bool InstalledOnly=true);
478 
479  // Size queries
480  inline signed long long UsrSize() {return iUsrSize;};
481  inline unsigned long long DebSize() {return iDownloadSize;};
482  inline unsigned long DelCount() {return iDelCount;};
483  inline unsigned long KeepCount() {return iKeepCount;};
484  inline unsigned long InstCount() {return iInstCount;};
485  inline unsigned long BrokenCount() {return iBrokenCount;};
486  inline unsigned long PolicyBrokenCount() {return iPolicyBrokenCount;};
487  inline unsigned long BadCount() {return iBadCount;};
488 
489  bool Init(OpProgress *Prog);
490  // Generate all state information
491  void Update(OpProgress *Prog = 0);
492 
493  pkgDepCache(pkgCache *Cache,Policy *Plcy = 0);
494  virtual ~pkgDepCache();
495 
496  protected:
497  // methods call by IsInstallOk
498  bool IsInstallOkMultiArchSameVersionSynced(PkgIterator const &Pkg,
499  bool const AutoInst, unsigned long const Depth, bool const FromUser);
500 
501  // methods call by IsDeleteOk
502  bool IsDeleteOkProtectInstallRequests(PkgIterator const &Pkg,
503  bool const rPurge, unsigned long const Depth, bool const FromUser);
504 
505  private:
506  bool IsModeChangeOk(ModeList const mode, PkgIterator const &Pkg,
507  unsigned long const Depth, bool const FromUser);
508 };
509 
510 #endif