]> git.saurik.com Git - apt.git/blame - apt-pkg/packagemanager.cc
projects / apt.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Config class and source list
[apt.git] / apt-pkg / packagemanager.cc
CommitLineData
6c139d6e
AL		 1// -*- mode: cpp; mode: fold -*-
2// Description /*{{{*/
3// $Id: packagemanager.cc,v 1.1 1998/07/07 04:17:01 jgg Exp $
4/* ######################################################################
5
6 Package Manager - Abstacts the package manager
7
8 More work is needed in the area of transitioning provides, ie exim
9 replacing smail. This can cause interesing side effects.
10
11 Other cases involving conflicts+replaces should be tested.
12
13 ##################################################################### */
14 /*}}}*/
15// Include Files /*{{{*/
16#ifdef __GNUG__
17#pragma implementation "pkglib/packagemanager.h"
18#endif
19#include <pkglib/packagemanager.h>
20#include <pkglib/orderlist.h>
21#include <pkglib/depcache.h>
22#include <pkglib/sourcelist.h>
23#include <pkglib/aquire.h>
24#include <pkglib/controlcache.h>
25#include <pkglib/error.h>
26#include <options.h>
27 /*}}}*/
28
29// PM::PackageManager - Constructor /*{{{*/
30// ---------------------------------------------------------------------
31/* */
32pkgPackageManager::pkgPackageManager(pkgDepCache &Cache) : Cache(Cache)
33{
34 FileNames = new string[Cache.Head().PackageCount];
35 List = 0;
36}
37 /*}}}*/
38// PM::PackageManager - Destructor /*{{{*/
39// ---------------------------------------------------------------------
40/* */
41pkgPackageManager::~pkgPackageManager()
42{
43 delete List;
44 delete [] FileNames;
45}
46 /*}}}*/
47// PM::GetArchives - Puts the install archives in the aquire list /*{{{*/
48// ---------------------------------------------------------------------
49/* The Source list is used to convert the packages to install into
50 URNs which are then passed to Aquire to convert to FileNames. */
51bool pkgPackageManager::GetArchives(pkgSourceList &List,pkgAquire &Engine)
52{
53 pkgControlCache CCache(Cache);
54 if (_error->PendingError() == true)
55 return false;
56
57 Engine.OutputDir(PKG_DEB_CA_ARCHIVES);
58 pkgCache::PkgIterator I = Cache.PkgBegin();
59 for (;I.end() != true; I++)
60 {
61 // Not interesting
62 if ((Cache[I].InstallVer == (pkgCache::Version *)I.CurrentVer() &&
63 I.State() != pkgCache::PkgIterator::NeedsUnpack) ||
64 Cache[I].Delete() == true)
65 continue;
66
67 // Cross match with the source list.
68 pkgSourceList::const_iterator Dist = List.MatchPkgFile(Cache[I].InstVerIter(Cache));
69 if (Dist == List.end())
70 {
71 _error->Warning("Couldn't locate an archive source for package %s",I.Name());
72 continue;
73 }
74
75 // Read in the info record
76 pkgSPkgCtrlInfo Inf = CCache[Cache[I].InstVerIter(Cache)];
77 if (Inf.isNull() == true)
78 {
79 _error->Warning("Couldn't locate info for package %s",I.Name());
80 continue;
81 }
82
83 // Isolate the filename
84 string File = Inf->Find("Filename")->Value();
85 if (File.empty() == true)
86 {
87 _error->Warning("Couldn't locate an archive for package %s",I.Name());
88 continue;
89 }
90
91 // Generate the get request.
92 string URI = Dist->ArchiveURI(File);
93
94 // Output file
95 unsigned int Pos = File.rfind('/');
96 if (Pos == File.length())
97 return _error->Error("Malformed file line in package %s",I.Name());
98
99 // Null pos isnt used in present package files
100 if (Pos == string::npos)
101 Pos = 0;
102 else
103 Pos++;
104
105 if (Engine.Get(URI,string(File,Pos),
106 Dist->ArchiveInfo(Cache[I].InstVerIter(Cache)),
107 Cache[I].InstVerIter(Cache)->Size,
108 Inf->Find("MD5sum")->Value(),
109 &FileNames[I->ID]) == false)
110 return false;
111 }
112
113 return true;
114}
115 /*}}}*/
116// PM::FixMissing - Keep all missing packages /*{{{*/
117// ---------------------------------------------------------------------
118/* This is called to correct the installation when packages could not
119 be downloaded. */
120bool pkgPackageManager::FixMissing()
121{
122 unsigned char *Touch = new unsigned char[Cache.Head().PackageCount];
123 for (PkgIterator I = Cache.PkgBegin(); I.end() == false; I++)
124 {
125 // Create the status list that ResolveConflicts needs
126 if ((Cache[I].DepState & pkgDepCache::DepNowMin) == pkgDepCache::DepNowMin)
127 Touch[I->ID] = (1 << 0) | (1 << 1);
128 else
129 Touch[I->ID] = 1 << 1;
130
131 if (Cache[I].Keep() == true)
132 continue;
133 if (FileNames[I->ID].empty() == false || Cache[I].Delete() == true)
134 continue;
135 Cache.MarkKeep(I);
136 }
137
138 // Now downgrade everything that is broken
139 Cache.ResolveConflicts(Touch);
140 delete [] Touch;
141
142 return Cache.BrokenCount() == 0;
143}
144 /*}}}*/
145
146// PM::DepAlwaysTrue - Returns true if this dep is irrelevent /*{{{*/
147// ---------------------------------------------------------------------
148/* The restriction on provides is to eliminate the case when provides
149 are transitioning between valid states [ie exim to smail] */
150bool pkgPackageManager::DepAlwaysTrue(DepIterator D)
151{
152 if (D.TargetPkg()->ProvidesList != 0)
153 return false;
154
155 if ((Cache[D] & pkgDepCache::DepInstall) != 0 &&
156 (Cache[D] & pkgDepCache::DepNow) != 0)
157 return true;
158 return false;
159}
160 /*}}}*/
161// PM::CheckRConflicts - Look for reverse conflicts /*{{{*/
162// ---------------------------------------------------------------------
163/* This looks over the reverses for a conflicts line that needs early
164 removal. */
165bool pkgPackageManager::CheckRConflicts(PkgIterator Pkg,DepIterator D,
166 const char *Ver)
167{
168 for (;D.end() == false; D++)
169 {
170 if (D->Type != pkgDEP_Conflicts)
171 continue;
172
173 if (D.ParentPkg() == Pkg)
174 continue;
175
176 if (pkgCheckDep(D.TargetVer(),Ver,D->CompareOp) == false)
177 continue;
178
179 if (List->IsNow(Pkg) == false)
180 continue;
181
182 if (EarlyRemove(D.ParentPkg()) == false)
183 return false;
184 }
185 return true;
186}
187 /*}}}*/
188// PM::ConfigureAll - Run the all out configuration /*{{{*/
189// ---------------------------------------------------------------------
190/* This configures every package. It is assumed they are all unpacked and
191 that the final configuration is valid. */
192bool pkgPackageManager::ConfigureAll()
193{
194 pkgOrderList OList(Cache);
195
196 // Populate the order list
197 for (pkgOrderList::iterator I = List->begin(); I != List->end(); I++)
198 if (List->IsFlag(pkgCache::PkgIterator(Cache,*I),
199 pkgOrderList::UnPacked) == true)
200 OList.push_back(*I);
201
202 if (OList.OrderConfigure() == false)
203 return false;
204
205 // Perform the configuring
206 for (pkgOrderList::iterator I = OList.begin(); I != OList.end(); I++)
207 {
208 PkgIterator Pkg(Cache,*I);
209
210 if (Configure(Pkg) == false)
211 return false;
212
213 List->Flag(Pkg,pkgOrderList::Configured,pkgOrderList::States);
214 }
215
216 return true;
217}
218 /*}}}*/
219// PM::SmartConfigure - Perform immediate configuration of the pkg /*{{{*/
220// ---------------------------------------------------------------------
221/* This routine scheduals the configuration of the given package and all
222 of it's dependents. */
223bool pkgPackageManager::SmartConfigure(PkgIterator Pkg)
224{
225 pkgOrderList OList(Cache);
226
227 if (DepAdd(OList,Pkg) == false)
228 return false;
229
230 if (OList.OrderConfigure() == false)
231 return false;
232
233 // Perform the configuring
234 for (pkgOrderList::iterator I = OList.begin(); I != OList.end(); I++)
235 {
236 PkgIterator Pkg(Cache,*I);
237
238 if (Configure(Pkg) == false)
239 return false;
240
241 List->Flag(Pkg,pkgOrderList::Configured,pkgOrderList::States);
242 }
243
244 // Sanity Check
245 if (List->IsFlag(Pkg,pkgOrderList::Configured) == false)
246 return _error->Error("Internal error, could not immediate configure %s",Pkg.Name());
247
248 return true;
249}
250 /*}}}*/
251// PM::DepAdd - Add all dependents to the oder list /*{{{*/
252// ---------------------------------------------------------------------
253/* This recursively adds all dependents to the order list */
254bool pkgPackageManager::DepAdd(pkgOrderList &OList,PkgIterator Pkg,int Depth)
255{
256 if (OList.IsFlag(Pkg,pkgOrderList::Added) == true)
257 return true;
258 if (List->IsFlag(Pkg,pkgOrderList::Configured) == true)
259 return true;
260 if (List->IsFlag(Pkg,pkgOrderList::UnPacked) == false)
261 return false;
262
263
264 // Put the package on the list
265 OList.push_back(Pkg);
266 OList.Flag(Pkg,pkgOrderList::Added);
267 Depth++;
268
269 // Check the dependencies to see if they are all satisfied.
270 bool Bad = false;
271 for (DepIterator D = Cache[Pkg].InstVerIter(Cache).DependsList(); D.end() == false;)
272 {
273 if (D->Type != pkgDEP_Depends && D->Type != pkgDEP_PreDepends)
274 {
275 D++;
276 continue;
277 }
278
279 // Grok or groups
280 Bad = true;
281 for (bool LastOR = true; D.end() == false && LastOR == true; D++)
282 {
283 LastOR = (D->CompareOp & pkgOP_OR) == pkgOP_OR;
284
285 if (Bad == false)
286 continue;
287
288 Version **VList = D.AllTargets();
289 for (Version **I = VList; *I != 0 && Bad == true; I++)
290 {
291 VerIterator Ver(Cache,*I);
292 PkgIterator Pkg = Ver.ParentPkg();
293
294 // See if the current version is ok
295 if (Pkg.CurrentVer() == Ver && List->IsNow(Pkg) == true &&
296 Pkg.State() == PkgIterator::NeedsNothing)
297 {
298 Bad = false;
299 continue;
300 }
301
302 // Not the install version
303 if (Cache[Pkg].InstallVer != *I ||
304 (Cache[Pkg].Keep() == true && Pkg.State() == PkgIterator::NeedsNothing))
305 continue;
306 if (List->IsFlag(Pkg,pkgOrderList::UnPacked) == true)
307 Bad = !DepAdd(OList,Pkg,Depth);
308 if (List->IsFlag(Pkg,pkgOrderList::Configured) == true)
309 Bad = false;
310 }
311 delete [] VList;
312 }
313
314 if (Bad == true)
315 {
316 OList.Flag(Pkg,0,pkgOrderList::Added);
317 OList.pop_back();
318 Depth--;
319 return false;
320 }
321 }
322
323 Depth--;
324 return true;
325}
326 /*}}}*/
327// PM::EarlyRemove - Perform removal of packages before their time /*{{{*/
328// ---------------------------------------------------------------------
329/* This is called to deal with conflicts arising from unpacking */
330bool pkgPackageManager::EarlyRemove(PkgIterator Pkg)
331{
332 if (List->IsNow(Pkg) == false)
333 return true;
334
335 // Already removed it
336 if (List->IsFlag(Pkg,pkgOrderList::Removed) == true)
337 return true;
338
339 // Woops, it will not be re-installed!
340 if (List->IsFlag(Pkg,pkgOrderList::InList) == false)
341 return false;
342
343 bool Res = SmartRemove(Pkg);
344 if (Cache[Pkg].Delete() == false)
345 List->Flag(Pkg,pkgOrderList::Removed,pkgOrderList::States);
346
347 return Res;
348}
349 /*}}}*/
350// PM::SmartRemove - Removal Helper /*{{{*/
351// ---------------------------------------------------------------------
352/* */
353bool pkgPackageManager::SmartRemove(PkgIterator Pkg)
354{
355 if (List->IsNow(Pkg) == false)
356 return true;
357
358 List->Flag(Pkg,pkgOrderList::Configured,pkgOrderList::States);
359 return Remove(Pkg);
360}
361 /*}}}*/
362// PM::SmartUnPack - Install helper /*{{{*/
363// ---------------------------------------------------------------------
364/* This performs the task of handling pre-depends. */
365bool pkgPackageManager::SmartUnPack(PkgIterator Pkg)
366{
367 // Check if it is already unpacked
368 if (Pkg.State() == pkgCache::PkgIterator::NeedsConfigure &&
369 Cache[Pkg].Keep() == true)
370 {
371 List->Flag(Pkg,pkgOrderList::UnPacked,pkgOrderList::States);
372 if (List->IsFlag(Pkg,pkgOrderList::Immediate) == true)
373 if (SmartConfigure(Pkg) == false)
374 return _error->Error("Internal Error, Could not perform immediate configuraton");
375 return true;
376 }
377
378 /* See if this packages install version has any predependencies
379 that are not met by 'now' packages. */
380 for (DepIterator D = Cache[Pkg].InstVerIter(Cache).DependsList();
381 D.end() == false; D++)
382 {
383 if (D->Type == pkgDEP_PreDepends)
384 {
385 // Look for possible ok targets.
386 Version **VList = D.AllTargets();
387 bool Bad = true;
388 for (Version **I = VList; *I != 0 && Bad == true; I++)
389 {
390 VerIterator Ver(Cache,*I);
391 PkgIterator Pkg = Ver.ParentPkg();
392
393 // See if the current version is ok
394 if (Pkg.CurrentVer() == Ver && List->IsNow(Pkg) == true &&
395 Pkg.State() == PkgIterator::NeedsNothing)
396 {
397 Bad = false;
398 continue;
399 }
400 }
401
402 // Look for something that could be configured.
403 for (Version **I = VList; *I != 0 && Bad == true; I++)
404 {
405 VerIterator Ver(Cache,*I);
406 PkgIterator Pkg = Ver.ParentPkg();
407
408 // Not the install version
409 if (Cache[Pkg].InstallVer != *I ||
410 (Cache[Pkg].Keep() == true && Pkg.State() == PkgIterator::NeedsNothing))
411 continue;
412
413 Bad = !SmartConfigure(Pkg);
414 }
415
416 delete [] VList;
417
418 if (Bad == true)
419 return _error->Error("Internal Error, Couldn't configure a pre-depend");
420
421 continue;
422 }
423
424 if (D->Type == pkgDEP_Conflicts)
425 {
426 /* Look for conflicts. Two packages that are both in the install
427 state cannot conflict so we don't check.. */
428 Version **VList = D.AllTargets();
429 for (Version **I = VList; *I != 0; I++)
430 {
431 VerIterator Ver(Cache,*I);
432 PkgIterator Pkg = Ver.ParentPkg();
433
434 // See if the current version is conflicting
435 if (Pkg.CurrentVer() == Ver && List->IsNow(Pkg) == true)
436 {
437 if (EarlyRemove(Pkg) == false)
438 return _error->Error("Internal Error, Could not early remove %s",Pkg.Name());
439 }
440 }
441 delete [] VList;
442 }
443 }
444
445 // Check for reverse conflicts.
446 CheckRConflicts(Pkg,Pkg.RevDependsList(),
447 Cache[Pkg].InstVerIter(Cache).VerStr());
448 for (PrvIterator P = Cache[Pkg].InstVerIter(Cache).ProvidesList();
449 P.end() == false; P++)
450 CheckRConflicts(Pkg,P.ParentPkg().RevDependsList(),P.ProvideVersion());
451
452 if (Install(Pkg,FileNames[Pkg->ID]) == false)
453 return false;
454
455 List->Flag(Pkg,pkgOrderList::UnPacked,pkgOrderList::States);
456
457 // Perform immedate configuration of the package.
458 if (List->IsFlag(Pkg,pkgOrderList::Immediate) == true)
459 if (SmartConfigure(Pkg) == false)
460 return _error->Error("Internal Error, Could not perform immediate configuraton");
461
462 return true;
463}
464 /*}}}*/
465// PM::OrderInstall - Installation ordering routine /*{{{*/
466// ---------------------------------------------------------------------
467/* */
468bool pkgPackageManager::OrderInstall()
469{
470 delete List;
471 List = new pkgOrderList(Cache);
472
473 // Generate the list of affected packages and sort it
474 for (PkgIterator I = Cache.PkgBegin(); I.end() == false; I++)
475 {
476 // Consider all depends
477 if ((I->Flags & pkgFLAG_Essential) == pkgFLAG_Essential)
478 {
479 List->Flag(I,pkgOrderList::Immediate);
480 if (Cache[I].InstallVer != 0)
481 for (DepIterator D = Cache[I].InstVerIter(Cache).DependsList();
482 D.end() == false; D++)
483 if (D->Type == pkgDEP_Depends || D->Type == pkgDEP_PreDepends)
484 List->Flag(D.TargetPkg(),pkgOrderList::Immediate);
485 if (I->CurrentVer != 0)
486 for (DepIterator D = I.CurrentVer().DependsList();
487 D.end() == false; D++)
488 if (D->Type == pkgDEP_Depends || D->Type == pkgDEP_PreDepends)
489 List->Flag(D.TargetPkg(),pkgOrderList::Immediate);
490 }
491
492 // Not interesting
493 if ((Cache[I].Keep() == true ||
494 Cache[I].InstVerIter(Cache) == I.CurrentVer()) &&
495 I.State() == pkgCache::PkgIterator::NeedsNothing)
496 continue;
497
498 // Append it to the list
499 List->push_back(I);
500
501 if ((I->Flags & pkgFLAG_ImmediateConf) == pkgFLAG_ImmediateConf)
502 List->Flag(I,pkgOrderList::Immediate);
503 }
504
505 if (List->OrderUnpack() == false)
506 return _error->Error("Internal ordering error");
507
508 for (pkgOrderList::iterator I = List->begin(); I != List->end(); I++)
509 {
510 PkgIterator Pkg(Cache,*I);
511
512 // Sanity check
513 if (Cache[Pkg].Keep() == true && Pkg.State() == pkgCache::PkgIterator::NeedsNothing)
514 return _error->Error("Internal Error, trying to manipulate a kept package");
515
516 // Perform a delete or an install
517 if (Cache[Pkg].Delete() == true)
518 {
519 if (SmartRemove(Pkg) == false)
520 return false;
521 }
522 else
523 if (SmartUnPack(Pkg) == false)
524 return false;
525 }
526
527 // Final run through the configure phase
528 if (ConfigureAll() == false)
529 return false;
530
531 // Sanity check
532 for (pkgOrderList::iterator I = List->begin(); I != List->end(); I++)
533 if (List->IsFlag(*I,pkgOrderList::Configured) == false)
534 return _error->Error("Internal error, packages left unconfigured. %s",
535 PkgIterator(Cache,*I).Name());
536
537 return true;
538}
539 /*}}}*/
540// PM::DoInstall - Does the installation /*{{{*/
541// ---------------------------------------------------------------------
542/* This uses the filenames in FileNames and the information in the
543 DepCache to perform the installation of packages.*/
544bool pkgPackageManager::DoInstall()
545{
546 return OrderInstall() && Go();
547}
548 /*}}}*/
APT (for Cydia)