]>
git.saurik.com Git - apt.git/blob - apt-pkg/depcache.h
1 // -*- mode: c++; mode: fold -*-
3 // $Id: depcache.h,v 1.14 2001/02/20 07:03:17 jgg Exp $
4 /* ######################################################################
6 DepCache - Dependency Extension data for the cache
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.
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.
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 persistent data
19 files will be put on the disk.
21 Each dependency is compared against 3 target versions to produce to
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.
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.
34 The Candidate version is what is shown the 'Install Version' field.
36 ##################################################################### */
38 #ifndef PKGLIB_DEPCACHE_H
39 #define PKGLIB_DEPCACHE_H
41 #include <apt-pkg/configuration.h>
42 #include <apt-pkg/pkgcache.h>
43 #include <apt-pkg/cacheiterators.h>
44 #include <apt-pkg/macros.h>
53 #ifndef APT_8_CLEANER_HEADERS
54 #include <apt-pkg/progress.h>
55 #include <apt-pkg/error.h>
57 #ifndef APT_10_CLEANER_HEADERS
63 class pkgVersioningSystem
;
65 class pkgDepCache
: protected pkgCache::Namespace
69 /** \brief An arbitrary predicate on packages. */
73 virtual bool InRootSet(const pkgCache::PkgIterator
&/*pkg*/) {return false;};
74 virtual ~InRootSetFunc() {};
78 /** \brief Mark a single package and all its unmarked important
79 * dependencies during mark-and-sweep.
81 * Recursively invokes itself to mark all dependencies of the
84 * \param pkg The package to mark.
86 * \param ver The version of the package that is to be marked.
88 * \param follow_recommends If \b true, recommendations of the
89 * package will be recursively marked.
91 * \param follow_suggests If \b true, suggestions of the package
92 * will be recursively marked.
94 void MarkPackage(const pkgCache::PkgIterator
&pkg
,
95 const pkgCache::VerIterator
&ver
,
96 bool const &follow_recommends
,
97 bool const &follow_suggests
);
99 /** \brief Update the Marked field of all packages.
101 * Each package's StateCache::Marked field will be set to \b true
102 * if and only if it can be reached from the root set. By
103 * default, the root set consists of the set of manually installed
104 * or essential packages, but it can be extended using the
105 * parameter #rootFunc.
107 * \param rootFunc A callback that can be used to add extra
108 * packages to the root set.
110 * \return \b false if an error occurred.
112 bool MarkRequired(InRootSetFunc
&rootFunc
);
114 /** \brief Set the StateCache::Garbage flag on all packages that
117 * Packages that were not marked by the last call to #MarkRequired
118 * are tested to see whether they are actually garbage. If so,
119 * they are marked as such.
121 * \return \b false if an error occurred.
127 // These flags are used in DepState
128 enum DepFlags
{DepNow
= (1 << 0),DepInstall
= (1 << 1),DepCVer
= (1 << 2),
129 DepGNow
= (1 << 3),DepGInstall
= (1 << 4),DepGCVer
= (1 << 5)};
131 // These flags are used in StateCache::DepState
132 enum DepStateFlags
{DepNowPolicy
= (1 << 0), DepNowMin
= (1 << 1),
133 DepInstPolicy
= (1 << 2), DepInstMin
= (1 << 3),
134 DepCandPolicy
= (1 << 4), DepCandMin
= (1 << 5)};
136 // These flags are used in StateCache::iFlags
137 enum InternalFlags
{AutoKept
= (1 << 0), Purge
= (1 << 1), ReInstall
= (1 << 2), Protected
= (1 << 3)};
139 enum VersionTypes
{NowVersion
, InstallVersion
, CandidateVersion
};
140 enum ModeList
{ModeDelete
= 0, ModeKeep
= 1, ModeInstall
= 2, ModeGarbage
= 3};
142 /** \brief Represents an active action group.
144 * An action group is a group of actions that are currently being
145 * performed. While an active group is active, certain routine
146 * clean-up actions that would normally be performed after every
147 * cache operation are delayed until the action group is
148 * completed. This is necessary primarily to avoid inefficiencies
149 * when modifying a large number of packages at once.
151 * This class represents an active action group. Creating an
152 * instance will create an action group; destroying one will
153 * destroy the corresponding action group.
155 * The following operations are suppressed by this class:
157 * - Keeping the Marked and Garbage flags up to date.
159 * \note This can be used in the future to easily accumulate
160 * atomic actions for undo or to display "what apt did anyway";
161 * e.g., change the counter of how many action groups are active
162 * to a std::set of pointers to them and use those to store
163 * information about what happened in a group in the group.
171 /** Action groups are noncopyable. */
172 ActionGroup(const ActionGroup
&other
);
174 /** \brief Create a new ActionGroup.
176 * \param cache The cache that this ActionGroup should
179 * As long as this object exists, no automatic cleanup
180 * operations will be undertaken.
182 ActionGroup(pkgDepCache
&cache
);
184 /** \brief Clean up the action group before it is destroyed.
186 * If it is destroyed later, no second cleanup wil be run.
190 /** \brief Destroy the action group.
192 * If this is the last action group, the automatic cache
193 * cleanup operations will be undertaken.
198 /** \brief Returns \b true for packages matching a regular
199 * expression in APT::NeverAutoRemove.
201 class DefaultRootSetFunc
: public InRootSetFunc
, public Configuration::MatchAgainstConfig
204 DefaultRootSetFunc() : Configuration::MatchAgainstConfig("APT::NeverAutoRemove") {};
205 virtual ~DefaultRootSetFunc() {};
207 bool InRootSet(const pkgCache::PkgIterator
&pkg
) { return pkg
.end() == false && Match(pkg
.Name()); };
212 // Epoch stripped text versions of the two version fields
213 const char *CandVersion
;
214 const char *CurVersion
;
216 // Pointer to the candidate install version.
217 Version
*CandidateVer
;
219 // Pointer to the install version.
222 // Copy of Package::Flags
223 unsigned short Flags
;
224 unsigned short iFlags
; // Internal flags
226 /** \brief \b true if this package can be reached from the root set. */
229 /** \brief \b true if this package is unused and should be removed.
231 * This differs from !#Marked, because it is possible that some
232 * unreachable packages will be protected from becoming
237 // Various tree indicators
238 signed char Status
; // -1,0,1,2
239 unsigned char Mode
; // ModeList
240 unsigned char DepState
; // DepState Flags
242 // Update of candidate version
243 const char *StripEpoch(const char *Ver
) APT_PURE
;
244 void Update(PkgIterator Pkg
,pkgCache
&Cache
);
246 // Various test members for the current status of the package
247 inline bool NewInstall() const {return Status
== 2 && Mode
== ModeInstall
;};
248 inline bool Delete() const {return Mode
== ModeDelete
;};
249 inline bool Purge() const {return Delete() == true && (iFlags
& pkgDepCache::Purge
) == pkgDepCache::Purge
; };
250 inline bool Keep() const {return Mode
== ModeKeep
;};
251 inline bool Protect() const {return (iFlags
& Protected
) == Protected
;};
252 inline bool Upgrade() const {return Status
> 0 && Mode
== ModeInstall
;};
253 inline bool Upgradable() const {return Status
>= 1;};
254 inline bool Downgrade() const {return Status
< 0 && Mode
== ModeInstall
;};
255 inline bool Held() const {return Status
!= 0 && Keep();};
256 inline bool NowBroken() const {return (DepState
& DepNowMin
) != DepNowMin
;};
257 inline bool NowPolicyBroken() const {return (DepState
& DepNowPolicy
) != DepNowPolicy
;};
258 inline bool InstBroken() const {return (DepState
& DepInstMin
) != DepInstMin
;};
259 inline bool InstPolicyBroken() const {return (DepState
& DepInstPolicy
) != DepInstPolicy
;};
260 inline bool Install() const {return Mode
== ModeInstall
;};
261 inline bool ReInstall() const {return Delete() == false && (iFlags
& pkgDepCache::ReInstall
) == pkgDepCache::ReInstall
;};
262 inline VerIterator
InstVerIter(pkgCache
&Cache
)
263 {return VerIterator(Cache
,InstallVer
);};
264 inline VerIterator
CandidateVerIter(pkgCache
&Cache
)
265 {return VerIterator(Cache
,CandidateVer
);};
269 void BuildGroupOrs(VerIterator
const &V
);
270 void UpdateVerState(PkgIterator Pkg
);
272 // User Policy control
277 InstallRecommends
= _config
->FindB("APT::Install-Recommends", false);
278 InstallSuggests
= _config
->FindB("APT::Install-Suggests", false);
281 virtual VerIterator
GetCandidateVer(PkgIterator
const &Pkg
);
282 virtual bool IsImportantDep(DepIterator
const &Dep
);
283 virtual signed short GetPriority(PkgIterator
const &Pkg
);
284 virtual signed short GetPriority(PkgFileIterator
const &File
);
286 virtual ~Policy() {};
289 bool InstallRecommends
;
290 bool InstallSuggests
;
294 /** The number of open "action groups"; certain post-action
295 * operations are suppressed if this number is > 0.
299 friend class ActionGroup
;
305 StateCache
*PkgState
;
306 unsigned char *DepState
;
308 /** Stores the space changes after installation */
309 signed long long iUsrSize
;
310 /** Stores how much we need to download to get the packages */
311 unsigned long long iDownloadSize
;
312 unsigned long iInstCount
;
313 unsigned long iDelCount
;
314 unsigned long iKeepCount
;
315 unsigned long iBrokenCount
;
316 unsigned long iPolicyBrokenCount
;
317 unsigned long iBadCount
;
320 bool DebugAutoInstall
;
322 Policy
*delLocalPolicy
; // For memory clean up..
325 // Check for a matching provides
326 bool CheckDep(DepIterator Dep
,int Type
,PkgIterator
&Res
);
327 inline bool CheckDep(DepIterator Dep
,int Type
)
329 PkgIterator
Res(*this,0);
330 return CheckDep(Dep
,Type
,Res
);
333 // Computes state information for deps and versions (w/o storing)
334 unsigned char DependencyState(DepIterator
&D
);
335 unsigned char VersionState(DepIterator D
,unsigned char Check
,
336 unsigned char SetMin
,
337 unsigned char SetPolicy
);
339 // Recalculates various portions of the cache, call after changing something
340 void Update(DepIterator Dep
); // Mostly internal
341 void Update(PkgIterator
const &P
);
343 // Count manipulators
344 void AddSizes(const PkgIterator
&Pkg
, bool const Invert
= false);
345 inline void RemoveSizes(const PkgIterator
&Pkg
) {AddSizes(Pkg
, true);};
346 void AddStates(const PkgIterator
&Pkg
, bool const Invert
= false);
347 inline void RemoveStates(const PkgIterator
&Pkg
) {AddStates(Pkg
,true);};
351 // Legacy.. We look like a pkgCache
352 inline operator pkgCache
&() {return *Cache
;};
353 inline Header
&Head() {return *Cache
->HeaderP
;};
354 inline GrpIterator
GrpBegin() {return Cache
->GrpBegin();};
355 inline PkgIterator
PkgBegin() {return Cache
->PkgBegin();};
356 inline GrpIterator
FindGrp(std::string
const &Name
) {return Cache
->FindGrp(Name
);};
357 inline PkgIterator
FindPkg(std::string
const &Name
) {return Cache
->FindPkg(Name
);};
358 inline PkgIterator
FindPkg(std::string
const &Name
, std::string
const &Arch
) {return Cache
->FindPkg(Name
, Arch
);};
360 inline pkgCache
&GetCache() {return *Cache
;};
361 inline pkgVersioningSystem
&VS() {return *Cache
->VS
;};
363 // Policy implementation
364 inline VerIterator
GetCandidateVer(PkgIterator
const &Pkg
) {return LocalPolicy
->GetCandidateVer(Pkg
);};
365 inline bool IsImportantDep(DepIterator Dep
) {return LocalPolicy
->IsImportantDep(Dep
);};
366 inline Policy
&GetPolicy() {return *LocalPolicy
;};
369 inline StateCache
&operator [](PkgIterator
const &I
) {return PkgState
[I
->ID
];};
370 inline unsigned char &operator [](DepIterator
const &I
) {return DepState
[I
->ID
];};
372 /** \return A function identifying packages in the root set other
373 * than manually installed packages and essential packages, or \b
374 * NULL if an error occurs.
376 * \todo Is this the best place for this function? Perhaps the
377 * settings for mark-and-sweep should be stored in a single
380 virtual InRootSetFunc
*GetRootSetFunc();
382 /** \return \b true if the garbage collector should follow recommendations.
384 virtual bool MarkFollowsRecommends();
386 /** \return \b true if the garbage collector should follow suggestions.
388 virtual bool MarkFollowsSuggests();
390 /** \brief Update the Marked and Garbage fields of all packages.
392 * This routine is implicitly invoked after all state manipulators
393 * and when an ActionGroup is destroyed. It invokes the private
394 * MarkRequired() and Sweep() to do its dirty work.
396 * \param rootFunc A predicate that returns \b true for packages
397 * that should be added to the root set.
399 bool MarkAndSweep(InRootSetFunc
&rootFunc
)
401 return MarkRequired(rootFunc
) && Sweep();
406 std::auto_ptr
<InRootSetFunc
> f(GetRootSetFunc());
408 return MarkAndSweep(*f
.get());
413 /** \name State Manipulators
416 bool MarkKeep(PkgIterator
const &Pkg
, bool Soft
= false,
417 bool FromUser
= true, unsigned long Depth
= 0);
418 bool MarkDelete(PkgIterator
const &Pkg
, bool MarkPurge
= false,
419 unsigned long Depth
= 0, bool FromUser
= true);
420 bool MarkInstall(PkgIterator
const &Pkg
,bool AutoInst
= true,
421 unsigned long Depth
= 0, bool FromUser
= true,
422 bool ForceImportantDeps
= false);
423 void MarkProtected(PkgIterator
const &Pkg
) { PkgState
[Pkg
->ID
].iFlags
|= Protected
; };
425 void SetReInstall(PkgIterator
const &Pkg
,bool To
);
426 void SetCandidateVersion(VerIterator TargetVer
);
427 bool SetCandidateRelease(pkgCache::VerIterator TargetVer
,
428 std::string
const &TargetRel
);
429 /** Set the candidate version for dependencies too if needed.
431 * Sets not only the candidate version as SetCandidateVersion does,
432 * but walks also down the dependency tree and checks if it is required
433 * to set the candidate of the dependency to a version from the given
436 * \param TargetVer new candidate version of the package
437 * \param TargetRel try to switch to this release if needed
438 * \param[out] Changed a list of pairs consisting of the \b old
439 * version of the changed package and the version which
440 * required the switch of this dependency
441 * \return \b true if the switch was successful, \b false otherwise
443 bool SetCandidateRelease(pkgCache::VerIterator TargetVer
,
444 std::string
const &TargetRel
,
445 std::list
<std::pair
<pkgCache::VerIterator
, pkgCache::VerIterator
> > &Changed
);
447 /** Set the "is automatically installed" flag of Pkg. */
448 void MarkAuto(const PkgIterator
&Pkg
, bool Auto
);
451 /** \return \b true if it's OK for MarkInstall to install
454 * The default implementation simply calls all IsInstallOk*
455 * method mentioned below.
457 * Overriding implementations should use the hold-state-flag to
458 * cache results from previous checks of this package - if possible.
460 * The parameters are the same as in the calling MarkInstall:
461 * \param Pkg the package that MarkInstall wants to install.
462 * \param AutoInst install this and all its dependencies
463 * \param Depth recursive deep of this Marker call
464 * \param FromUser was the install requested by the user?
466 virtual bool IsInstallOk(const PkgIterator
&Pkg
,bool AutoInst
= true,
467 unsigned long Depth
= 0, bool FromUser
= true);
469 /** \return \b true if it's OK for MarkDelete to remove
472 * The default implementation simply calls all IsDeleteOk*
473 * method mentioned below, see also #IsInstallOk.
475 * The parameters are the same as in the calling MarkDelete:
476 * \param Pkg the package that MarkDelete wants to remove.
477 * \param MarkPurge should we purge instead of "only" remove?
478 * \param Depth recursive deep of this Marker call
479 * \param FromUser was the remove requested by the user?
481 virtual bool IsDeleteOk(const PkgIterator
&Pkg
,bool MarkPurge
= false,
482 unsigned long Depth
= 0, bool FromUser
= true);
484 // read persistent states
485 bool readStateFile(OpProgress
*prog
);
486 bool writeStateFile(OpProgress
*prog
, bool InstalledOnly
=true);
489 inline signed long long UsrSize() {return iUsrSize
;};
490 inline unsigned long long DebSize() {return iDownloadSize
;};
491 inline unsigned long DelCount() {return iDelCount
;};
492 inline unsigned long KeepCount() {return iKeepCount
;};
493 inline unsigned long InstCount() {return iInstCount
;};
494 inline unsigned long BrokenCount() {return iBrokenCount
;};
495 inline unsigned long PolicyBrokenCount() {return iPolicyBrokenCount
;};
496 inline unsigned long BadCount() {return iBadCount
;};
498 bool Init(OpProgress
*Prog
);
499 // Generate all state information
500 void Update(OpProgress
*Prog
= 0);
502 pkgDepCache(pkgCache
*Cache
,Policy
*Plcy
= 0);
503 virtual ~pkgDepCache();
506 // methods call by IsInstallOk
507 bool IsInstallOkMultiArchSameVersionSynced(PkgIterator
const &Pkg
,
508 bool const AutoInst
, unsigned long const Depth
, bool const FromUser
);
510 // methods call by IsDeleteOk
511 bool IsDeleteOkProtectInstallRequests(PkgIterator
const &Pkg
,
512 bool const rPurge
, unsigned long const Depth
, bool const FromUser
);
515 bool IsModeChangeOk(ModeList
const mode
, PkgIterator
const &Pkg
,
516 unsigned long const Depth
, bool const FromUser
);