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