apt-pkg/packagemanager.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: packagemanager.cc,v 1.21 1999/09/30 06:30:34 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 "apt-pkg/packagemanager.h"
  18 #endif
  19 #include <apt-pkg/packagemanager.h>
  20 #include <apt-pkg/orderlist.h>
  21 #include <apt-pkg/depcache.h>
  22 #include <apt-pkg/error.h>
  23 #include <apt-pkg/version.h>
  24 #include <apt-pkg/acquire-item.h>
  25 #include <apt-pkg/algorithms.h>
  26 #include <apt-pkg/configuration.h>
  27                                                                         /*}}}*/
  28
  29 // PM::PackageManager - Constructor                                     /*{{{*/
  30 // ---------------------------------------------------------------------
  31 /* */
  32 pkgPackageManager::pkgPackageManager(pkgDepCache &Cache) : Cache(Cache)
  33 {
  34    FileNames = new string[Cache.Head().PackageCount];
  35    List = 0;
  36    Debug = _config->FindB("Debug::pkgPackageManager",false);
  37 }
  38                                                                         /*}}}*/
  39 // PM::PackageManager - Destructor                                      /*{{{*/
  40 // ---------------------------------------------------------------------
  41 /* */
  42 pkgPackageManager::~pkgPackageManager()
  43 {
  44    delete List;
  45    delete [] FileNames;
  46 }
  47                                                                         /*}}}*/
  48 // PM::GetArchives - Queue the archives for download                    /*{{{*/
  49 // ---------------------------------------------------------------------
  50 /* */
  51 bool pkgPackageManager::GetArchives(pkgAcquire *Owner,pkgSourceList *Sources,
  52                                     pkgRecords *Recs)
  53 {
  54    if (CreateOrderList() == false)
  55       return false;
  56
  57    if (List->OrderUnpack() == false)
  58       return _error->Error("Internal ordering error");
  59
  60    for (pkgOrderList::iterator I = List->begin(); I != List->end(); I++)
  61    {
  62       PkgIterator Pkg(Cache,*I);
  63       FileNames[Pkg->ID] = string();
  64
  65       // Skip packages to erase
  66       if (Cache[Pkg].Delete() == true)
  67          continue;
  68
  69       // Skip Packages that need configure only.
  70       if (Pkg.State() == pkgCache::PkgIterator::NeedsConfigure &&
  71           Cache[Pkg].Keep() == true)
  72          continue;
  73
  74       // Skip already processed packages
  75       if (List->IsNow(Pkg) == false)
  76          continue;
  77
  78       new pkgAcqArchive(Owner,Sources,Recs,Cache[Pkg].InstVerIter(Cache),
  79                         FileNames[Pkg->ID]);
  80    }
  81
  82    return true;
  83 }
  84                                                                         /*}}}*/
  85 // PM::FixMissing - Keep all missing packages                           /*{{{*/
  86 // ---------------------------------------------------------------------
  87 /* This is called to correct the installation when packages could not
  88    be downloaded. */
  89 bool pkgPackageManager::FixMissing()
  90 {
  91    pkgProblemResolver Resolve(Cache);
  92    List->SetFileList(FileNames);
  93
  94    bool Bad = false;
  95    for (PkgIterator I = Cache.PkgBegin(); I.end() == false; I++)
  96    {
  97       if (List->IsMissing(I) == false)
  98          continue;
  99
 100       // Okay, this file is missing and we need it. Mark it for keep
 101       Bad = true;
 102       Cache.MarkKeep(I);
 103    }
 104
 105    // We have to empty the list otherwise it will not have the new changes
 106    delete List;
 107    List = 0;
 108
 109    if (Bad == false)
 110       return true;
 111
 112    // Now downgrade everything that is broken
 113    return Resolve.ResolveByKeep() == true && Cache.BrokenCount() == 0;
 114 }
 115                                                                         /*}}}*/
 116
 117 // PM::CreateOrderList - Create the ordering class                      /*{{{*/
 118 // ---------------------------------------------------------------------
 119 /* This populates the ordering list with all the packages that are
 120    going to change. */
 121 bool pkgPackageManager::CreateOrderList()
 122 {
 123    if (List != 0)
 124       return true;
 125
 126    delete List;
 127    List = new pkgOrderList(Cache);
 128
 129    bool NoImmConfigure = _config->FindB("APT::Immediate-Configure",false);
 130
 131    // Generate the list of affected packages and sort it
 132    for (PkgIterator I = Cache.PkgBegin(); I.end() == false; I++)
 133    {
 134       // Mark the package and its dependends for immediate configuration
 135       if (((I->Flags & pkgCache::Flag::Essential) == pkgCache::Flag::Essential ||
 136            (I->Flags & pkgCache::Flag::Important) == pkgCache::Flag::Important) &&
 137           NoImmConfigure == false)
 138       {
 139          List->Flag(I,pkgOrderList::Immediate);
 140
 141          // Look for other packages to make immediate configurea
 142          if (Cache[I].InstallVer != 0)
 143             for (DepIterator D = Cache[I].InstVerIter(Cache).DependsList();
 144                  D.end() == false; D++)
 145                if (D->Type == pkgCache::Dep::Depends || D->Type == pkgCache::Dep::PreDepends)
 146                   List->Flag(D.TargetPkg(),pkgOrderList::Immediate);
 147
 148          // And again with the current version.
 149          if (I->CurrentVer != 0)
 150             for (DepIterator D = I.CurrentVer().DependsList();
 151                  D.end() == false; D++)
 152                if (D->Type == pkgCache::Dep::Depends || D->Type == pkgCache::Dep::PreDepends)
 153                   List->Flag(D.TargetPkg(),pkgOrderList::Immediate);
 154       }
 155
 156       // Not interesting
 157       if ((Cache[I].Keep() == true ||
 158           Cache[I].InstVerIter(Cache) == I.CurrentVer()) &&
 159           I.State() == pkgCache::PkgIterator::NeedsNothing &&
 160           (I.Purge() != false || Cache[I].Mode != pkgDepCache::ModeDelete ||
 161            (Cache[I].iFlags & pkgDepCache::Purge) != pkgDepCache::Purge))
 162          continue;
 163
 164       // Append it to the list
 165       List->push_back(I);
 166    }
 167
 168    return true;
 169 }
 170                                                                         /*}}}*/
 171 // PM::DepAlwaysTrue - Returns true if this dep is irrelevent           /*{{{*/
 172 // ---------------------------------------------------------------------
 173 /* The restriction on provides is to eliminate the case when provides
 174    are transitioning between valid states [ie exim to smail] */
 175 bool pkgPackageManager::DepAlwaysTrue(DepIterator D)
 176 {
 177    if (D.TargetPkg()->ProvidesList != 0)
 178       return false;
 179
 180    if ((Cache[D] & pkgDepCache::DepInstall) != 0 &&
 181        (Cache[D] & pkgDepCache::DepNow) != 0)
 182       return true;
 183    return false;
 184 }
 185                                                                         /*}}}*/
 186 // PM::CheckRConflicts - Look for reverse conflicts                     /*{{{*/
 187 // ---------------------------------------------------------------------
 188 /* This looks over the reverses for a conflicts line that needs early
 189    removal. */
 190 bool pkgPackageManager::CheckRConflicts(PkgIterator Pkg,DepIterator D,
 191                                         const char *Ver)
 192 {
 193    for (;D.end() == false; D++)
 194    {
 195       if (D->Type != pkgCache::Dep::Conflicts)
 196          continue;
 197
 198       if (D.ParentPkg() == Pkg)
 199          continue;
 200
 201       if (pkgCheckDep(D.TargetVer(),Ver,D->CompareOp) == false)
 202          continue;
 203
 204       if (List->IsNow(Pkg) == false)
 205          continue;
 206
 207       if (EarlyRemove(D.ParentPkg()) == false)
 208          return false;
 209    }
 210    return true;
 211 }
 212                                                                         /*}}}*/
 213 // PM::ConfigureAll - Run the all out configuration                     /*{{{*/
 214 // ---------------------------------------------------------------------
 215 /* This configures every package. It is assumed they are all unpacked and
 216    that the final configuration is valid. */
 217 bool pkgPackageManager::ConfigureAll()
 218 {
 219    pkgOrderList OList(Cache);
 220
 221    // Populate the order list
 222    for (pkgOrderList::iterator I = List->begin(); I != List->end(); I++)
 223       if (List->IsFlag(pkgCache::PkgIterator(Cache,*I),
 224                        pkgOrderList::UnPacked) == true)
 225          OList.push_back(*I);
 226
 227    if (OList.OrderConfigure() == false)
 228       return false;
 229
 230    // Perform the configuring
 231    for (pkgOrderList::iterator I = OList.begin(); I != OList.end(); I++)
 232    {
 233       PkgIterator Pkg(Cache,*I);
 234
 235       if (Configure(Pkg) == false)
 236          return false;
 237
 238       List->Flag(Pkg,pkgOrderList::Configured,pkgOrderList::States);
 239    }
 240
 241    return true;
 242 }
 243                                                                         /*}}}*/
 244 // PM::SmartConfigure - Perform immediate configuration of the pkg      /*{{{*/
 245 // ---------------------------------------------------------------------
 246 /* This routine scheduals the configuration of the given package and all
 247    of it's dependents. */
 248 bool pkgPackageManager::SmartConfigure(PkgIterator Pkg)
 249 {
 250    pkgOrderList OList(Cache);
 251
 252    if (DepAdd(OList,Pkg) == false)
 253       return false;
 254
 255    if (OList.OrderConfigure() == false)
 256       return false;
 257
 258    // Perform the configuring
 259    for (pkgOrderList::iterator I = OList.begin(); I != OList.end(); I++)
 260    {
 261       PkgIterator Pkg(Cache,*I);
 262
 263       if (Configure(Pkg) == false)
 264          return false;
 265
 266       List->Flag(Pkg,pkgOrderList::Configured,pkgOrderList::States);
 267    }
 268
 269    // Sanity Check
 270    if (List->IsFlag(Pkg,pkgOrderList::Configured) == false)
 271       return _error->Error("Internal error, could not immediate configure %s",Pkg.Name());
 272
 273    return true;
 274 }
 275                                                                         /*}}}*/
 276 // PM::DepAdd - Add all dependents to the oder list                     /*{{{*/
 277 // ---------------------------------------------------------------------
 278 /* This recursively adds all dependents to the order list */
 279 bool pkgPackageManager::DepAdd(pkgOrderList &OList,PkgIterator Pkg,int Depth)
 280 {
 281    if (OList.IsFlag(Pkg,pkgOrderList::Added) == true)
 282       return true;
 283    if (List->IsFlag(Pkg,pkgOrderList::Configured) == true)
 284       return true;
 285    if (List->IsFlag(Pkg,pkgOrderList::UnPacked) == false)
 286       return false;
 287
 288
 289    // Put the package on the list
 290    OList.push_back(Pkg);
 291    OList.Flag(Pkg,pkgOrderList::Added);
 292    Depth++;
 293
 294    // Check the dependencies to see if they are all satisfied.
 295    bool Bad = false;
 296    for (DepIterator D = Cache[Pkg].InstVerIter(Cache).DependsList(); D.end() == false;)
 297    {
 298       if (D->Type != pkgCache::Dep::Depends && D->Type != pkgCache::Dep::PreDepends)
 299       {
 300          D++;
 301          continue;
 302       }
 303
 304       // Grok or groups
 305       Bad = true;
 306       for (bool LastOR = true; D.end() == false && LastOR == true; D++)
 307       {
 308          LastOR = (D->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or;
 309
 310          if (Bad == false)
 311             continue;
 312
 313          Version **VList = D.AllTargets();
 314          for (Version **I = VList; *I != 0 && Bad == true; I++)
 315          {
 316             VerIterator Ver(Cache,*I);
 317             PkgIterator Pkg = Ver.ParentPkg();
 318
 319             // See if the current version is ok
 320             if (Pkg.CurrentVer() == Ver && List->IsNow(Pkg) == true &&
 321                 Pkg.State() == PkgIterator::NeedsNothing)
 322             {
 323                Bad = false;
 324                continue;
 325             }
 326
 327             // Not the install version
 328             if (Cache[Pkg].InstallVer != *I ||
 329                 (Cache[Pkg].Keep() == true && Pkg.State() == PkgIterator::NeedsNothing))
 330                continue;
 331             if (List->IsFlag(Pkg,pkgOrderList::UnPacked) == true)
 332                Bad = !DepAdd(OList,Pkg,Depth);
 333             if (List->IsFlag(Pkg,pkgOrderList::Configured) == true)
 334                Bad = false;
 335          }
 336          delete [] VList;
 337       }
 338
 339       if (Bad == true)
 340       {
 341          OList.Flag(Pkg,0,pkgOrderList::Added);
 342          OList.pop_back();
 343          Depth--;
 344          return false;
 345       }
 346    }
 347
 348    Depth--;
 349    return true;
 350 }
 351                                                                         /*}}}*/
 352 // PM::EarlyRemove - Perform removal of packages before their time      /*{{{*/
 353 // ---------------------------------------------------------------------
 354 /* This is called to deal with conflicts arising from unpacking */
 355 bool pkgPackageManager::EarlyRemove(PkgIterator Pkg)
 356 {
 357    if (List->IsNow(Pkg) == false)
 358       return true;
 359
 360    // Already removed it
 361    if (List->IsFlag(Pkg,pkgOrderList::Removed) == true)
 362       return true;
 363
 364    // Woops, it will not be re-installed!
 365    if (List->IsFlag(Pkg,pkgOrderList::InList) == false)
 366       return false;
 367
 368    // Essential packages get special treatment
 369    if ((Pkg->Flags & pkgCache::Flag::Essential) != 0)
 370    {
 371       if (_config->FindB("APT::Force-LoopBreak",false) == false)
 372          return _error->Error("This installation run will require temporarily "
 373                               "removing the essential package %s due to a "
 374                               "Conflicts/Pre-Depends loop. This is often bad, "
 375                               "but if you really want to do it, activate the "
 376                               "APT::Force-LoopBreak option.",Pkg.Name());
 377    }
 378
 379    bool Res = SmartRemove(Pkg);
 380    if (Cache[Pkg].Delete() == false)
 381       List->Flag(Pkg,pkgOrderList::Removed,pkgOrderList::States);
 382
 383    return Res;
 384 }
 385                                                                         /*}}}*/
 386 // PM::SmartRemove - Removal Helper                                     /*{{{*/
 387 // ---------------------------------------------------------------------
 388 /* */
 389 bool pkgPackageManager::SmartRemove(PkgIterator Pkg)
 390 {
 391    if (List->IsNow(Pkg) == false)
 392       return true;
 393
 394    List->Flag(Pkg,pkgOrderList::Configured,pkgOrderList::States);
 395    return Remove(Pkg,(Cache[Pkg].iFlags & pkgDepCache::Purge) == pkgDepCache::Purge);
 396 }
 397                                                                         /*}}}*/
 398 // PM::SmartUnPack - Install helper                                     /*{{{*/
 399 // ---------------------------------------------------------------------
 400 /* This performs the task of handling pre-depends. */
 401 bool pkgPackageManager::SmartUnPack(PkgIterator Pkg)
 402 {
 403    // Check if it is already unpacked
 404    if (Pkg.State() == pkgCache::PkgIterator::NeedsConfigure &&
 405        Cache[Pkg].Keep() == true)
 406    {
 407       List->Flag(Pkg,pkgOrderList::UnPacked,pkgOrderList::States);
 408       if (List->IsFlag(Pkg,pkgOrderList::Immediate) == true)
 409          if (SmartConfigure(Pkg) == false)
 410             return _error->Error("Internal Error, Could not perform immediate configuraton");
 411       return true;
 412    }
 413
 414    /* See if this packages install version has any predependencies
 415       that are not met by 'now' packages. */
 416    for (DepIterator D = Cache[Pkg].InstVerIter(Cache).DependsList();
 417         D.end() == false; )
 418    {
 419       // Compute a single dependency element (glob or)
 420       pkgCache::DepIterator Start;
 421       pkgCache::DepIterator End;
 422       D.GlobOr(Start,End);
 423
 424       while (End->Type == pkgCache::Dep::PreDepends)
 425       {
 426          // Look for possible ok targets.
 427          Version **VList = Start.AllTargets();
 428          bool Bad = true;
 429          for (Version **I = VList; *I != 0 && Bad == true; I++)
 430          {
 431             VerIterator Ver(Cache,*I);
 432             PkgIterator Pkg = Ver.ParentPkg();
 433
 434             // See if the current version is ok
 435             if (Pkg.CurrentVer() == Ver && List->IsNow(Pkg) == true &&
 436                 Pkg.State() == PkgIterator::NeedsNothing)
 437             {
 438                Bad = false;
 439                continue;
 440             }
 441          }
 442
 443          // Look for something that could be configured.
 444          for (Version **I = VList; *I != 0 && Bad == true; I++)
 445          {
 446             VerIterator Ver(Cache,*I);
 447             PkgIterator Pkg = Ver.ParentPkg();
 448
 449             // Not the install version
 450             if (Cache[Pkg].InstallVer != *I ||
 451                 (Cache[Pkg].Keep() == true && Pkg.State() == PkgIterator::NeedsNothing))
 452                continue;
 453
 454             Bad = !SmartConfigure(Pkg);
 455          }
 456
 457          delete [] VList;
 458
 459          /* If this or element did not match then continue on to the
 460             next or element until a matching element is found*/
 461          if (Bad == true)
 462          {
 463             if (Start == End)
 464                return _error->Error("Internal Error, Couldn't configure a pre-depend");
 465             Start++;
 466          }
 467          else
 468             break;
 469       }
 470
 471       if (End->Type == pkgCache::Dep::Conflicts)
 472       {
 473          /* Look for conflicts. Two packages that are both in the install
 474             state cannot conflict so we don't check.. */
 475          Version **VList = End.AllTargets();
 476          for (Version **I = VList; *I != 0; I++)
 477          {
 478             VerIterator Ver(Cache,*I);
 479             PkgIterator Pkg = Ver.ParentPkg();
 480
 481             // See if the current version is conflicting
 482             if (Pkg.CurrentVer() == Ver && List->IsNow(Pkg) == true)
 483             {
 484                if (EarlyRemove(Pkg) == false)
 485                   return _error->Error("Internal Error, Could not early remove %s",Pkg.Name());
 486             }
 487          }
 488          delete [] VList;
 489       }
 490    }
 491
 492    // Check for reverse conflicts.
 493    CheckRConflicts(Pkg,Pkg.RevDependsList(),
 494                    Cache[Pkg].InstVerIter(Cache).VerStr());
 495    for (PrvIterator P = Cache[Pkg].InstVerIter(Cache).ProvidesList();
 496         P.end() == false; P++)
 497       CheckRConflicts(Pkg,P.ParentPkg().RevDependsList(),P.ProvideVersion());
 498
 499    if (Install(Pkg,FileNames[Pkg->ID]) == false)
 500       return false;
 501
 502    List->Flag(Pkg,pkgOrderList::UnPacked,pkgOrderList::States);
 503
 504    // Perform immedate configuration of the package.
 505    if (List->IsFlag(Pkg,pkgOrderList::Immediate) == true)
 506       if (SmartConfigure(Pkg) == false)
 507          return _error->Error("Internal Error, Could not perform immediate configuraton");
 508
 509    return true;
 510 }
 511                                                                         /*}}}*/
 512 // PM::OrderInstall - Installation ordering routine                     /*{{{*/
 513 // ---------------------------------------------------------------------
 514 /* */
 515 pkgPackageManager::OrderResult pkgPackageManager::OrderInstall()
 516 {
 517    if (CreateOrderList() == false)
 518       return Failed;
 519
 520    Reset();
 521
 522    if (Debug == true)
 523       clog << "Begining to order" << endl;
 524
 525    if (List->OrderUnpack(FileNames) == false)
 526    {
 527       _error->Error("Internal ordering error");
 528       return Failed;
 529    }
 530
 531    if (Debug == true)
 532       clog << "Done ordering" << endl;
 533
 534    bool DoneSomething = false;
 535    for (pkgOrderList::iterator I = List->begin(); I != List->end(); I++)
 536    {
 537       PkgIterator Pkg(Cache,*I);
 538
 539       if (List->IsNow(Pkg) == false)
 540       {
 541          if (Debug == true)
 542             clog << "Skipping already done " << Pkg.Name() << endl;
 543          continue;
 544       }
 545
 546       if (List->IsMissing(Pkg) == true)
 547       {
 548          if (Debug == true)
 549             clog << "Sequence completed at" << Pkg.Name() << endl;
 550          if (DoneSomething == false)
 551          {
 552             _error->Error("Internal Error, ordering was unable to handle the media swap");
 553             return Failed;
 554          }
 555          return Incomplete;
 556       }
 557
 558       // Sanity check
 559       if (Cache[Pkg].Keep() == true && Pkg.State() == pkgCache::PkgIterator::NeedsNothing)
 560       {
 561          _error->Error("Internal Error, trying to manipulate a kept package");
 562          return Failed;
 563       }
 564
 565       // Perform a delete or an install
 566       if (Cache[Pkg].Delete() == true)
 567       {
 568          if (SmartRemove(Pkg) == false)
 569             return Failed;
 570       }
 571       else
 572          if (SmartUnPack(Pkg) == false)
 573             return Failed;
 574       DoneSomething = true;
 575    }
 576
 577    // Final run through the configure phase
 578    if (ConfigureAll() == false)
 579       return Failed;
 580
 581    // Sanity check
 582    for (pkgOrderList::iterator I = List->begin(); I != List->end(); I++)
 583    {
 584       if (List->IsFlag(*I,pkgOrderList::Configured) == false)
 585       {
 586          _error->Error("Internal error, packages left unconfigured. %s",
 587                        PkgIterator(Cache,*I).Name());
 588          return Failed;
 589       }
 590    }
 591
 592    return Completed;
 593 }
 594                                                                         /*}}}*/
 595 // PM::DoInstall - Does the installation                                /*{{{*/
 596 // ---------------------------------------------------------------------
 597 /* This uses the filenames in FileNames and the information in the
 598    DepCache to perform the installation of packages.*/
 599 pkgPackageManager::OrderResult pkgPackageManager::DoInstall()
 600 {
 601    OrderResult Res = OrderInstall();
 602    if (Res != Failed)
 603       if (Go() == false)
 604          return Failed;
 605    return Res;
 606 }
 607                                                                         /*}}}*/