zypp/target/TargetImpl.cc

   1 /*---------------------------------------------------------------------\
   2 |                          ____ _   __ __ ___                          |
   3 |                         |__  / \ / / . \ . \                         |
   4 |                           / / \ V /|  _/  _/                         |
   5 |                          / /__ | | | | | |                           |
   6 |                         /_____||_| |_| |_|                           |
   7 |                                                                      |
   8 \---------------------------------------------------------------------*/
   9 /** \file       zypp/target/TargetImpl.cc
  10  *
  11 */
  12 #include <iostream>
  13 #include <fstream>
  14 #include <sstream>
  15 #include <string>
  16 #include <list>
  17 #include <set>
  18
  19 #include <sys/types.h>
  20 #include <dirent.h>
  21
  22 #include "zypp/base/LogTools.h"
  23 #include "zypp/base/Exception.h"
  24 #include "zypp/base/Iterator.h"
  25 #include "zypp/base/Gettext.h"
  26 #include "zypp/base/IOStream.h"
  27 #include "zypp/base/Functional.h"
  28 #include "zypp/base/UserRequestException.h"
  29
  30 #include "zypp/ZConfig.h"
  31 #include "zypp/ZYppFactory.h"
  32
  33 #include "zypp/PoolItem.h"
  34 #include "zypp/ResObjects.h"
  35 #include "zypp/Url.h"
  36 #include "zypp/TmpPath.h"
  37 #include "zypp/RepoStatus.h"
  38 #include "zypp/ExternalProgram.h"
  39 #include "zypp/Repository.h"
  40
  41 #include "zypp/ResFilters.h"
  42 #include "zypp/HistoryLog.h"
  43 #include "zypp/target/TargetImpl.h"
  44 #include "zypp/target/TargetCallbackReceiver.h"
  45 #include "zypp/target/rpm/librpmDb.h"
  46 #include "zypp/target/CommitPackageCache.h"
  47
  48 #include "zypp/parser/ProductFileReader.h"
  49
  50 #include "zypp/pool/GetResolvablesToInsDel.h"
  51 #include "zypp/solver/detail/Helper.h"
  52
  53 #include "zypp/repo/DeltaCandidates.h"
  54 #include "zypp/repo/PackageProvider.h"
  55 #include "zypp/repo/SrcPackageProvider.h"
  56
  57 #include "zypp/sat/Pool.h"
  58
  59 using namespace std;
  60
  61 ///////////////////////////////////////////////////////////////////
  62 namespace zypp
  63 { /////////////////////////////////////////////////////////////////
  64   ///////////////////////////////////////////////////////////////////
  65   namespace target
  66   { /////////////////////////////////////////////////////////////////
  67
  68     ///////////////////////////////////////////////////////////////////
  69     namespace
  70     { /////////////////////////////////////////////////////////////////
  71
  72       /** Execute script and report against report_r.
  73        * Return \c std::pair<bool,PatchScriptReport::Action> to indicate if
  74        * execution was successfull (<tt>first = true</tt>), or the desired
  75        * \c PatchScriptReport::Action in case execution failed
  76        * (<tt>first = false</tt>).
  77        *
  78        * \note The packager is responsible for setting the correct permissions
  79        * of the script. If the script is not executable it is reported as an
  80        * error. We must not modify the permessions.
  81        */
  82       std::pair<bool,PatchScriptReport::Action> doExecuteScript( const Pathname & root_r,
  83                                                                  const Pathname & script_r,
  84                                                                  callback::SendReport<PatchScriptReport> & report_r )
  85       {
  86         MIL << "Execute script " << PathInfo(script_r) << endl;
  87
  88         HistoryLog historylog;
  89         historylog.comment(script_r.asString() + _(" executed"), /*timestamp*/true);
  90         ExternalProgram prog( script_r.asString(), ExternalProgram::Stderr_To_Stdout, false, -1, true, root_r );
  91
  92         for ( std::string output = prog.receiveLine(); output.length(); output = prog.receiveLine() )
  93         {
  94           historylog.comment(output);
  95           if ( ! report_r->progress( PatchScriptReport::OUTPUT, output ) )
  96           {
  97             WAR << "User request to abort script " << script_r << endl;
  98             prog.kill();
  99             // the rest is handled by exit code evaluation
 100             // in case the script has meanwhile finished.
 101           }
 102         }
 103
 104         std::pair<bool,PatchScriptReport::Action> ret( std::make_pair( false, PatchScriptReport::ABORT ) );
 105
 106         if ( prog.close() != 0 )
 107         {
 108           ret.second = report_r->problem( prog.execError() );
 109           WAR << "ACTION" << ret.second << "(" << prog.execError() << ")" << endl;
 110           std::ostringstream sstr;
 111           sstr << script_r << _(" execution failed") << " (" << prog.execError() << ")" << endl;
 112           historylog.comment(sstr.str(), /*timestamp*/true);
 113           return ret;
 114         }
 115
 116         report_r->finish();
 117         ret.first = true;
 118         return ret;
 119       }
 120
 121       /** Execute script and report against report_r.
 122        * Return \c false if user requested \c ABORT.
 123        */
 124       bool executeScript( const Pathname & root_r,
 125                           const Pathname & script_r,
 126                           callback::SendReport<PatchScriptReport> & report_r )
 127       {
 128         std::pair<bool,PatchScriptReport::Action> action( std::make_pair( false, PatchScriptReport::ABORT ) );
 129
 130         do {
 131           action = doExecuteScript( root_r, script_r, report_r );
 132           if ( action.first )
 133             return true; // success
 134
 135           switch ( action.second )
 136           {
 137             case PatchScriptReport::ABORT:
 138               WAR << "User request to abort at script " << script_r << endl;
 139               return false; // requested abort.
 140               break;
 141
 142             case PatchScriptReport::IGNORE:
 143               WAR << "User request to skip script " << script_r << endl;
 144               return true; // requested skip.
 145               break;
 146
 147             case PatchScriptReport::RETRY:
 148               break; // again
 149           }
 150         } while ( action.second == PatchScriptReport::RETRY );
 151
 152         // THIS is not intended to be reached:
 153         INT << "Abort on unknown ACTION request " << action.second << " returned" << endl;
 154         return false; // abort.
 155       }
 156
 157       /** Look for patch scripts named 'name-version-release-*' and
 158        *  execute them. Return \c false if \c ABORT was requested.
 159        */
 160       bool RunUpdateScripts( const Pathname & root_r,
 161                              const Pathname & scriptsPath_r,
 162                              const std::vector<sat::Solvable> & checkPackages_r,
 163                              bool aborting_r )
 164       {
 165         if ( checkPackages_r.empty() )
 166           return true; // no installed packages to check
 167
 168         MIL << "Looking for new patch scripts in (" <<  root_r << ")" << scriptsPath_r << endl;
 169         Pathname scriptsDir( Pathname::assertprefix( root_r, scriptsPath_r ) );
 170         if ( ! PathInfo( scriptsDir ).isDir() )
 171           return true; // no script dir
 172
 173         std::list<std::string> scripts;
 174         filesystem::readdir( scripts, scriptsDir, /*dots*/false );
 175         if ( scripts.empty() )
 176           return true; // no scripts in script dir
 177
 178         // Now collect and execute all matching scripts.
 179         // On ABORT: at least log all outstanding scripts.
 180         bool abort = false;
 181         for_( it, checkPackages_r.begin(), checkPackages_r.end() )
 182         {
 183           std::string prefix( str::form( "%s-%s-", it->name().c_str(), it->edition().c_str() ) );
 184           for_( sit, scripts.begin(), scripts.end() )
 185           {
 186             if ( ! str::hasPrefix( *sit, prefix ) )
 187               continue;
 188
 189             PathInfo script( scriptsDir / *sit );
 190             if ( ! script.isFile() )
 191               continue;
 192
 193             if ( abort || aborting_r )
 194             {
 195               WAR << "Aborting: Skip patch script " << *sit << endl;
 196               HistoryLog().comment(
 197                   script.path().asString() + _(" execution skipped while aborting"),
 198                   /*timestamp*/true);
 199             }
 200             else
 201             {
 202               MIL << "Found patch script " << *sit << endl;
 203               callback::SendReport<PatchScriptReport> report;
 204               report->start( make<Package>( *it ), script.path() );
 205
 206               if ( ! executeScript( root_r, script.path(), report ) )
 207                 abort = true; // requested abort.
 208             }
 209           }
 210         }
 211         return !abort;
 212       }
 213
 214       /////////////////////////////////////////////////////////////////
 215     } // namespace
 216     ///////////////////////////////////////////////////////////////////
 217
 218     /** Helper for PackageProvider queries during commit. */
 219     struct QueryInstalledEditionHelper
 220     {
 221       bool operator()( const std::string & name_r,
 222                        const Edition &     ed_r,
 223                        const Arch &        arch_r ) const
 224       {
 225         rpm::librpmDb::db_const_iterator it;
 226         for ( it.findByName( name_r ); *it; ++it )
 227           {
 228             if ( arch_r == it->tag_arch()
 229                  && ( ed_r == Edition::noedition || ed_r == it->tag_edition() ) )
 230               {
 231                 return true;
 232               }
 233           }
 234         return false;
 235       }
 236     };
 237
 238     /**
 239      * \short Let the Source provide the package.
 240      * \p pool_r \ref ResPool used to get candidates
 241      * \p pi item to be commited
 242     */
 243     struct RepoProvidePackage
 244     {
 245       ResPool _pool;
 246       repo::RepoMediaAccess &_access;
 247
 248       RepoProvidePackage( repo::RepoMediaAccess &access, ResPool pool_r )
 249         : _pool(pool_r), _access(access)
 250       {
 251
 252       }
 253
 254       ManagedFile operator()( const PoolItem & pi )
 255       {
 256         // Redirect PackageProvider queries for installed editions
 257         // (in case of patch/delta rpm processing) to rpmDb.
 258         repo::PackageProviderPolicy packageProviderPolicy;
 259         packageProviderPolicy.queryInstalledCB( QueryInstalledEditionHelper() );
 260
 261         Package::constPtr p = asKind<Package>(pi.resolvable());
 262
 263
 264         // Build a repository list for repos
 265         // contributing to the pool
 266         std::list<Repository> repos( _pool.knownRepositoriesBegin(), _pool.knownRepositoriesEnd() );
 267         repo::DeltaCandidates deltas(repos, p->name());
 268         repo::PackageProvider pkgProvider( _access, p, deltas, packageProviderPolicy );
 269         return pkgProvider.providePackage();
 270       }
 271     };
 272     ///////////////////////////////////////////////////////////////////
 273
 274     IMPL_PTR_TYPE(TargetImpl);
 275
 276     TargetImpl_Ptr TargetImpl::_nullimpl;
 277
 278     /** Null implementation */
 279     TargetImpl_Ptr TargetImpl::nullimpl()
 280     {
 281       if (_nullimpl == 0)
 282         _nullimpl = new TargetImpl;
 283       return _nullimpl;
 284     }
 285
 286     ///////////////////////////////////////////////////////////////////
 287     //
 288     //  METHOD NAME : TargetImpl::TargetImpl
 289     //  METHOD TYPE : Ctor
 290     //
 291     TargetImpl::TargetImpl( const Pathname & root_r, bool doRebuild_r )
 292     : _root( root_r )
 293     , _requestedLocalesFile( home() / "RequestedLocales" )
 294     , _softLocksFile( home() / "SoftLocks" )
 295     , _hardLocksFile( Pathname::assertprefix( _root, ZConfig::instance().locksFile() ) )
 296     {
 297       _rpm.initDatabase( root_r, Pathname(), doRebuild_r );
 298
 299       HistoryLog::setRoot(_root);
 300
 301       createAnonymousId();
 302
 303       MIL << "Initialized target on " << _root << endl;
 304     }
 305
 306     /**
 307      * generates a random id using uuidgen
 308      */
 309     static string generateRandomId()
 310     {
 311       string id;
 312       const char* argv[] =
 313       {
 314          "/usr/bin/uuidgen",
 315          NULL
 316       };
 317
 318       ExternalProgram prog( argv,
 319                             ExternalProgram::Normal_Stderr,
 320                             false, -1, true);
 321       std::string line;
 322       for(line = prog.receiveLine();
 323           ! line.empty();
 324           line = prog.receiveLine() )
 325       {
 326           MIL << line << endl;
 327           id = line;
 328           break;
 329       }
 330       prog.close();
 331       return id;
 332     }
 333
 334     /**
 335      * updates the content of \p filename
 336      * if \p condition is true, setting the content
 337      * the the value returned by \p value
 338      */
 339     void updateFileContent( const Pathname &filename,
 340                             boost::function<bool ()> condition,
 341                             boost::function<string ()> value )
 342     {
 343         string val = value();
 344         // if the value is empty, then just dont
 345         // do anything, regardless of the condition
 346         if ( val.empty() )
 347             return;
 348
 349         if ( condition() )
 350         {
 351             MIL << "updating '" << filename << "' content." << endl;
 352
 353             // if the file does not exist we need to generate the uuid file
 354
 355             std::ofstream filestr;
 356             // make sure the path exists
 357             filesystem::assert_dir( filename.dirname() );
 358             filestr.open( filename.c_str() );
 359
 360             if ( filestr.good() )
 361             {
 362                 filestr << val;
 363                 filestr.close();
 364             }
 365             else
 366             {
 367                 // FIXME, should we ignore the error?
 368                 ZYPP_THROW(Exception("Can't openfile '" + filename.asString() + "' for writing"));
 369             }
 370         }
 371     }
 372
 373     /** helper functor */
 374     static bool fileMissing( const Pathname &pathname )
 375     {
 376         return ! PathInfo(pathname).isExist();
 377     }
 378
 379     void TargetImpl::createAnonymousId() const
 380     {
 381
 382       // create the anonymous unique id
 383       // this value is used for statistics
 384       Pathname idpath( home() / "AnonymousUniqueId");
 385
 386       try
 387       {
 388         updateFileContent( idpath,
 389                            boost::bind(fileMissing, idpath),
 390                            generateRandomId );
 391       }
 392       catch ( const Exception &e )
 393       {
 394         WAR << "Can't create anonymous id file" << endl;
 395       }
 396
 397     }
 398
 399     void TargetImpl::createLastDistributionFlavorCache() const
 400     {
 401       // create the anonymous unique id
 402       // this value is used for statistics
 403       Pathname flavorpath( home() / "LastDistributionFlavor");
 404
 405       // is there a product
 406       Product::constPtr p = baseProduct();
 407       if ( ! p )
 408       {
 409           WAR << "No base product, I won't create flavor cache" << endl;
 410           return;
 411       }
 412
 413       string flavor = p->flavor();
 414
 415       try
 416       {
 417
 418         updateFileContent( flavorpath,
 419                            // only if flavor is not empty
 420                            functor::Constant<bool>( ! flavor.empty() ),
 421                            functor::Constant<string>(flavor) );
 422       }
 423       catch ( const Exception &e )
 424       {
 425         WAR << "Can't create flavor cache" << endl;
 426         return;
 427       }
 428     }
 429
 430     ///////////////////////////////////////////////////////////////////
 431     //
 432     //  METHOD NAME : TargetImpl::~TargetImpl
 433     //  METHOD TYPE : Dtor
 434     //
 435     TargetImpl::~TargetImpl()
 436     {
 437       _rpm.closeDatabase();
 438       MIL << "Targets closed" << endl;
 439     }
 440
 441     ///////////////////////////////////////////////////////////////////
 442     //
 443     // solv file handling
 444     //
 445     ///////////////////////////////////////////////////////////////////
 446
 447     Pathname TargetImpl::defaultSolvfilesPath() const
 448     {
 449       return Pathname::assertprefix( _root, ZConfig::instance().repoSolvfilesPath() / sat::Pool::instance().systemRepoAlias() );
 450     }
 451
 452     void TargetImpl::clearCache()
 453     {
 454       Pathname base = solvfilesPath();
 455       filesystem::recursive_rmdir( base );
 456     }
 457
 458     void TargetImpl::buildCache()
 459     {
 460       Pathname base = solvfilesPath();
 461       Pathname rpmsolv       = base/"solv";
 462       Pathname rpmsolvcookie = base/"cookie";
 463
 464       bool build_rpm_solv = true;
 465       // lets see if the rpm solv cache exists
 466
 467       RepoStatus rpmstatus( RepoStatus( _root/"/var/lib/rpm/Name" )
 468                             && (_root/"/etc/products.d") );
 469
 470       bool solvexisted = PathInfo(rpmsolv).isExist();
 471       if ( solvexisted )
 472       {
 473         // see the status of the cache
 474         PathInfo cookie( rpmsolvcookie );
 475         MIL << "Read cookie: " << cookie << endl;
 476         if ( cookie.isExist() )
 477         {
 478           RepoStatus status = RepoStatus::fromCookieFile(rpmsolvcookie);
 479           // now compare it with the rpm database
 480           if ( status.checksum() == rpmstatus.checksum() )
 481             build_rpm_solv = false;
 482           MIL << "Read cookie: " << rpmsolvcookie << " says: "
 483               << (build_rpm_solv ? "outdated" : "uptodate") << endl;
 484         }
 485       }
 486
 487       if ( build_rpm_solv )
 488       {
 489         // if the solvfile dir does not exist yet, we better create it
 490         filesystem::assert_dir( base );
 491
 492         Pathname oldSolvFile( solvexisted ? rpmsolv : Pathname() ); // to speedup rpmdb2solv
 493
 494         filesystem::TmpFile tmpsolv( filesystem::TmpFile::makeSibling( rpmsolv ) );
 495         if ( !tmpsolv )
 496         {
 497           // Can't create temporary solv file, usually due to insufficient permission
 498           // (user query while @System solv needs refresh). If so, try switching
 499           // to a location within zypps temp. space (will be cleaned at application end).
 500
 501           bool switchingToTmpSolvfile = false;
 502           Exception ex("Failed to cache rpm database.");
 503           ex.remember(str::form("Cannot create temporary file under %s.", base.c_str()));
 504
 505           if ( ! solvfilesPathIsTemp() )
 506           {
 507             base = getZYpp()->tmpPath() / sat::Pool::instance().systemRepoAlias();
 508             rpmsolv       = base/"solv";
 509             rpmsolvcookie = base/"cookie";
 510
 511             filesystem::assert_dir( base );
 512             tmpsolv = filesystem::TmpFile::makeSibling( rpmsolv );
 513
 514             if ( tmpsolv )
 515             {
 516               WAR << "Using a temporary solv file at " << base << endl;
 517               switchingToTmpSolvfile = true;
 518               _tmpSolvfilesPath = base;
 519             }
 520             else
 521             {
 522               ex.remember(str::form("Cannot create temporary file under %s.", base.c_str()));
 523             }
 524           }
 525
 526           if ( ! switchingToTmpSolvfile )
 527           {
 528             ZYPP_THROW(ex);
 529           }
 530         }
 531
 532         // Take care we unlink the solvfile on exception
 533         ManagedFile guard( base, filesystem::recursive_rmdir );
 534
 535         std::ostringstream cmd;
 536         cmd << "rpmdb2solv";
 537         if ( ! _root.empty() )
 538           cmd << " -r '" << _root << "'";
 539
 540         cmd << " -p '" << Pathname::assertprefix( _root, "/etc/products.d" ) << "'";
 541
 542         if ( ! oldSolvFile.empty() )
 543           cmd << " '" << oldSolvFile << "'";
 544
 545         cmd << "  > '" << tmpsolv.path() << "'";
 546
 547         MIL << "Executing: " << cmd << endl;
 548         ExternalProgram prog( cmd.str(), ExternalProgram::Stderr_To_Stdout );
 549
 550         cmd << endl;
 551         for ( std::string output( prog.receiveLine() ); output.length(); output = prog.receiveLine() ) {
 552           WAR << "  " << output;
 553           cmd << "     " << output;
 554         }
 555
 556         int ret = prog.close();
 557         if ( ret != 0 )
 558         {
 559           Exception ex(str::form("Failed to cache rpm database (%d).", ret));
 560           ex.remember( cmd.str() );
 561           ZYPP_THROW(ex);
 562         }
 563
 564         ret = filesystem::rename( tmpsolv, rpmsolv );
 565         if ( ret != 0 )
 566           ZYPP_THROW(Exception("Failed to move cache to final destination"));
 567         // if this fails, don't bother throwing exceptions
 568         filesystem::chmod( rpmsolv, 0644 );
 569
 570         rpmstatus.saveToCookieFile(rpmsolvcookie);
 571
 572         // We keep it.
 573         guard.resetDispose();
 574       }
 575     }
 576
 577     void TargetImpl::unload()
 578     {
 579       Repository system( sat::Pool::instance().findSystemRepo() );
 580       if ( system )
 581         system.eraseFromPool();
 582     }
 583
 584
 585     void TargetImpl::load()
 586     {
 587       buildCache();
 588
 589       // now add the repos to the pool
 590       sat::Pool satpool( sat::Pool::instance() );
 591       Pathname rpmsolv( solvfilesPath() / "solv" );
 592       MIL << "adding " << rpmsolv << " to pool(" << satpool.systemRepoAlias() << ")" << endl;
 593
 594       // Providing an empty system repo, unload any old content
 595       Repository system( sat::Pool::instance().findSystemRepo() );
 596       if ( system && ! system.solvablesEmpty() )
 597       {
 598         system.eraseFromPool(); // invalidates system
 599       }
 600       if ( ! system )
 601       {
 602         system = satpool.systemRepo();
 603       }
 604
 605       try
 606       {
 607         system.addSolv( rpmsolv );
 608       }
 609       catch ( const Exception & exp )
 610       {
 611         ZYPP_CAUGHT( exp );
 612         MIL << "Try to handle exception by rebuilding the solv-file" << endl;
 613         clearCache();
 614         buildCache();
 615
 616         system.addSolv( rpmsolv );
 617       }
 618
 619       // (Re)Load the requested locales et al.
 620       // If the requested locales are empty, we leave the pool untouched
 621       // to avoid undoing changes the application applied. We expect this
 622       // to happen on a bare metal installation only. An already existing
 623       // target should be loaded before its settings are changed.
 624       {
 625         const LocaleSet & requestedLocales( _requestedLocalesFile.locales() );
 626         if ( ! requestedLocales.empty() )
 627         {
 628           satpool.setRequestedLocales( requestedLocales );
 629         }
 630       }
 631       {
 632         SoftLocksFile::Data softLocks( _softLocksFile.data() );
 633         if ( ! softLocks.empty() )
 634         {
 635           // Don't soft lock any installed item.
 636           for_( it, system.solvablesBegin(), system.solvablesEnd() )
 637           {
 638             softLocks.erase( it->ident() );
 639           }
 640           ResPool::instance().setAutoSoftLocks( softLocks );
 641         }
 642       }
 643       if ( ZConfig::instance().apply_locks_file() )
 644       {
 645         const HardLocksFile::Data & hardLocks( _hardLocksFile.data() );
 646         if ( ! hardLocks.empty() )
 647         {
 648           ResPool::instance().setHardLockQueries( hardLocks );
 649         }
 650       }
 651
 652       // now that the target is loaded, we can cache the flavor
 653       createLastDistributionFlavorCache();
 654
 655       MIL << "Target loaded: " << system.solvablesSize() << " resolvables" << endl;
 656     }
 657
 658     ///////////////////////////////////////////////////////////////////
 659     //
 660     // COMMIT
 661     //
 662     ///////////////////////////////////////////////////////////////////
 663     ZYppCommitResult TargetImpl::commit( ResPool pool_r, const ZYppCommitPolicy & policy_rX )
 664     {
 665       // ----------------------------------------------------------------- //
 666       // Fake outstanding YCP fix: Honour restriction to media 1
 667       // at installation, but install all remaining packages if post-boot.
 668       ZYppCommitPolicy policy_r( policy_rX );
 669       if ( policy_r.restrictToMedia() > 1 )
 670         policy_r.allMedia();
 671       // ----------------------------------------------------------------- //
 672
 673       MIL << "TargetImpl::commit(<pool>, " << policy_r << ")" << endl;
 674
 675       ///////////////////////////////////////////////////////////////////
 676       // Store non-package data:
 677       ///////////////////////////////////////////////////////////////////
 678       filesystem::assert_dir( home() );
 679       // requested locales
 680       _requestedLocalesFile.setLocales( pool_r.getRequestedLocales() );
 681       // weak locks
 682       {
 683         SoftLocksFile::Data newdata;
 684         pool_r.getActiveSoftLocks( newdata );
 685         _softLocksFile.setData( newdata );
 686       }
 687       // hard locks
 688       if ( ZConfig::instance().apply_locks_file() )
 689       {
 690         HardLocksFile::Data newdata;
 691         pool_r.getHardLockQueries( newdata );
 692         _hardLocksFile.setData( newdata );
 693       }
 694
 695       ///////////////////////////////////////////////////////////////////
 696       // Process packages:
 697       ///////////////////////////////////////////////////////////////////
 698
 699       DBG << "commit log file is set to: " << HistoryLog::fname() << endl;
 700
 701       ZYppCommitResult result;
 702
 703       TargetImpl::PoolItemList to_uninstall;
 704       TargetImpl::PoolItemList to_install;
 705       TargetImpl::PoolItemList to_srcinstall;
 706       {
 707
 708         pool::GetResolvablesToInsDel
 709         collect( pool_r, policy_r.restrictToMedia() ? pool::GetResolvablesToInsDel::ORDER_BY_MEDIANR
 710                  : pool::GetResolvablesToInsDel::ORDER_BY_SOURCE );
 711         MIL << "GetResolvablesToInsDel: " << endl << collect << endl;
 712         to_uninstall.swap( collect._toDelete );
 713         to_install.swap( collect._toInstall );
 714         to_srcinstall.swap( collect._toSrcinstall );
 715       }
 716
 717       if ( policy_r.restrictToMedia() )
 718       {
 719         MIL << "Restrict to media number " << policy_r.restrictToMedia() << endl;
 720       }
 721
 722       ///////////////////////////////////////////////////////////////////
 723       // First collect and display all messages
 724       // associated with patches to be installed.
 725       ///////////////////////////////////////////////////////////////////
 726       for_( it, to_install.begin(), to_install.end() )
 727       {
 728         if ( ! isKind<Patch>(it->resolvable()) )
 729           continue;
 730         if ( ! it->status().isToBeInstalled() )
 731           continue;
 732
 733         Patch::constPtr patch( asKind<Patch>(it->resolvable()) );
 734         if ( ! patch->message().empty() )
 735         {
 736           MIL << "Show message for " << patch << endl;
 737           callback::SendReport<target::PatchMessageReport> report;
 738           if ( ! report->show( patch ) )
 739           {
 740             WAR << "commit aborted by the user" << endl;
 741             ZYPP_THROW( TargetAbortedException( N_("Installation has been aborted as directed.") ) );
 742           }
 743         }
 744       }
 745
 746       ///////////////////////////////////////////////////////////////////
 747       // Remove/install packages.
 748       ///////////////////////////////////////////////////////////////////
 749      commit ( to_uninstall, policy_r, pool_r );
 750
 751       if (policy_r.restrictToMedia() == 0)
 752       {                 // commit all
 753         result._remaining = commit( to_install, policy_r, pool_r );
 754         result._srcremaining = commit( to_srcinstall, policy_r, pool_r );
 755       }
 756       else
 757       {
 758         TargetImpl::PoolItemList current_install;
 759         TargetImpl::PoolItemList current_srcinstall;
 760
 761         // Collect until the 1st package from an unwanted media occurs.
 762         // Further collection could violate install order.
 763         bool hitUnwantedMedia = false;
 764         for (TargetImpl::PoolItemList::iterator it = to_install.begin(); it != to_install.end(); ++it)
 765         {
 766           ResObject::constPtr res( it->resolvable() );
 767
 768           if ( hitUnwantedMedia
 769                || ( res->mediaNr() && res->mediaNr() != policy_r.restrictToMedia() ) )
 770           {
 771             hitUnwantedMedia = true;
 772             result._remaining.push_back( *it );
 773           }
 774           else
 775           {
 776             current_install.push_back( *it );
 777           }
 778         }
 779
 780         TargetImpl::PoolItemList bad = commit( current_install, policy_r, pool_r );
 781         result._remaining.insert(result._remaining.end(), bad.begin(), bad.end());
 782
 783         for (TargetImpl::PoolItemList::iterator it = to_srcinstall.begin(); it != to_srcinstall.end(); ++it)
 784         {
 785           Resolvable::constPtr res( it->resolvable() );
 786           Package::constPtr pkg( asKind<Package>(res) );
 787           if (pkg && policy_r.restrictToMedia() != pkg->mediaNr()) // check medianr for packages only
 788           {
 789             XXX << "Package " << *pkg << ", wrong media " << pkg->mediaNr() << endl;
 790             result._srcremaining.push_back( *it );
 791           }
 792           else
 793           {
 794             current_srcinstall.push_back( *it );
 795           }
 796         }
 797         bad = commit( current_srcinstall, policy_r, pool_r );
 798         result._srcremaining.insert(result._srcremaining.end(), bad.begin(), bad.end());
 799       }
 800
 801       ///////////////////////////////////////////////////////////////////
 802       // Try to rebuild solv file while rpm database is still in cache.
 803       ///////////////////////////////////////////////////////////////////
 804       buildCache();
 805
 806       result._result = (to_install.size() - result._remaining.size());
 807       MIL << "TargetImpl::commit(<pool>, " << policy_r << ") returns: " << result << endl;
 808       return result;
 809     }
 810
 811
 812     ///////////////////////////////////////////////////////////////////
 813     //
 814     // COMMIT internal
 815     //
 816     ///////////////////////////////////////////////////////////////////
 817     TargetImpl::PoolItemList
 818     TargetImpl::commit( const TargetImpl::PoolItemList & items_r,
 819                         const ZYppCommitPolicy & policy_r,
 820                         const ResPool & pool_r )
 821     {
 822       TargetImpl::PoolItemList remaining;
 823       repo::RepoMediaAccess access;
 824       MIL << "TargetImpl::commit(<list>" << policy_r << ")" << items_r.size() << endl;
 825
 826       bool abort = false;
 827       std::vector<sat::Solvable> successfullyInstalledPackages;
 828
 829       // prepare the package cache.
 830       RepoProvidePackage repoProvidePackage( access, pool_r );
 831       CommitPackageCache packageCache( items_r.begin(), items_r.end(),
 832                                        root() / "tmp", repoProvidePackage );
 833
 834       for ( TargetImpl::PoolItemList::const_iterator it = items_r.begin(); it != items_r.end(); it++ )
 835       {
 836         if ( (*it)->isKind<Package>() )
 837         {
 838           Package::constPtr p = (*it)->asKind<Package>();
 839           if (it->status().isToBeInstalled())
 840           {
 841             ManagedFile localfile;
 842             try
 843             {
 844               localfile = packageCache.get( it );
 845             }
 846             catch ( const AbortRequestException &e )
 847             {
 848               WAR << "commit aborted by the user" << endl;
 849               abort = true;
 850               break;
 851             }
 852             catch ( const SkipRequestException &e )
 853             {
 854               ZYPP_CAUGHT( e );
 855               WAR << "Skipping package " << p << " in commit" << endl;
 856               continue;
 857             }
 858             catch ( const Exception &e )
 859             {
 860               // bnc #395704: missing catch causes abort.
 861               // TODO see if packageCache fails to handle errors correctly.
 862               ZYPP_CAUGHT( e );
 863               INT << "Unexpected Error: Skipping package " << p << " in commit" << endl;
 864               continue;
 865             }
 866
 867 #warning Exception handling
 868             // create a installation progress report proxy
 869             RpmInstallPackageReceiver progress( it->resolvable() );
 870             progress.connect(); // disconnected on destruction.
 871
 872             bool success = false;
 873             rpm::RpmInstFlags flags( policy_r.rpmInstFlags() & rpm::RPMINST_JUSTDB );
 874             // Why force and nodeps?
 875             //
 876             // Because zypp builds the transaction and the resolver asserts that
 877             // everything is fine.
 878             // We use rpm just to unpack and register the package in the database.
 879             // We do this step by step, so rpm is not aware of the bigger context.
 880             // So we turn off rpms internal checks, because we do it inside zypp.
 881             flags |= rpm::RPMINST_NODEPS;
 882             flags |= rpm::RPMINST_FORCE;
 883             //
 884             if (p->installOnly())          flags |= rpm::RPMINST_NOUPGRADE;
 885             if (policy_r.dryRun())         flags |= rpm::RPMINST_TEST;
 886             if (policy_r.rpmExcludeDocs()) flags |= rpm::RPMINST_EXCLUDEDOCS;
 887             if (policy_r.rpmNoSignature()) flags |= rpm::RPMINST_NOSIGNATURE;
 888
 889             try
 890             {
 891               progress.tryLevel( target::rpm::InstallResolvableReport::RPM_NODEPS_FORCE );
 892               rpm().installPackage( localfile, flags );
 893               HistoryLog().install(*it);
 894
 895               if ( progress.aborted() )
 896               {
 897                 WAR << "commit aborted by the user" << endl;
 898                 abort = true;
 899                 break;
 900               }
 901               else
 902               {
 903                 success = true;
 904               }
 905             }
 906             catch ( Exception & excpt_r )
 907             {
 908               ZYPP_CAUGHT(excpt_r);
 909               if ( policy_r.dryRun() )
 910               {
 911                 WAR << "dry run failed" << endl;
 912                 break;
 913               }
 914               // else
 915               if ( progress.aborted() )
 916               {
 917                 WAR << "commit aborted by the user" << endl;
 918                 abort = true;
 919               }
 920               else
 921               {
 922                 WAR << "Install failed" << endl;
 923               }
 924               remaining.push_back( *it );
 925               break; // stop
 926             }
 927
 928             if ( success && !policy_r.dryRun() )
 929             {
 930               it->status().resetTransact( ResStatus::USER );
 931               // Remember to check this package for presence of patch scripts.
 932               successfullyInstalledPackages.push_back( it->satSolvable() );
 933             }
 934           }
 935           else
 936           {
 937             RpmRemovePackageReceiver progress( it->resolvable() );
 938             progress.connect(); // disconnected on destruction.
 939
 940             bool success = false;
 941             rpm::RpmInstFlags flags( policy_r.rpmInstFlags() & rpm::RPMINST_JUSTDB );
 942             flags |= rpm::RPMINST_NODEPS;
 943             if (policy_r.dryRun()) flags |= rpm::RPMINST_TEST;
 944             try
 945             {
 946               rpm().removePackage( p, flags );
 947               HistoryLog().remove(*it);
 948
 949               if ( progress.aborted() )
 950               {
 951                 WAR << "commit aborted by the user" << endl;
 952                 abort = true;
 953                 break;
 954               }
 955               else
 956               {
 957                 success = true;
 958               }
 959             }
 960             catch (Exception & excpt_r)
 961             {
 962               ZYPP_CAUGHT( excpt_r );
 963               if ( progress.aborted() )
 964               {
 965                 WAR << "commit aborted by the user" << endl;
 966                 abort = true;
 967                 break;
 968               }
 969               // else
 970               WAR << "removal of " << p << " failed";
 971             }
 972             if ( success && !policy_r.dryRun() )
 973             {
 974               it->status().resetTransact( ResStatus::USER );
 975             }
 976           }
 977         }
 978         else if ( ! policy_r.dryRun() ) // other resolvables (non-Package)
 979         {
 980           // Status is changed as the buddy package buddy
 981           // gets installed/deleted. Handle non-buddies only.
 982           if ( ! it->buddy() )
 983           {
 984             if ( (*it)->isKind<Product>() )
 985             {
 986               Product::constPtr p = (*it)->asKind<Product>();
 987               if ( it->status().isToBeInstalled() )
 988               {
 989                 ERR << "Can't install orphan product without release-package! " << (*it) << endl;
 990               }
 991               else
 992               {
 993                 // Deleting the corresponding product entry is all we con do.
 994                 // So the product will no longer be visible as installed.
 995                 std::string referenceFilename( p->referenceFilename() );
 996                 if ( referenceFilename.empty() )
 997                 {
 998                   ERR << "Can't remove orphan product without 'referenceFilename'! " << (*it) << endl;
 999                 }
1000                 else
1001                 {
1002                   PathInfo referenceFile( Pathname::assertprefix( _root, Pathname( "/etc/products.d" ) ) / referenceFilename );
1003                   if ( ! referenceFile.isFile() || filesystem::unlink( referenceFile.path() ) != 0 )
1004                   {
1005                     ERR << "Delete orphan product failed: " << referenceFile << endl;
1006                   }
1007                 }
1008               }
1009             }
1010             else if ( (*it)->isKind<SrcPackage>() && it->status().isToBeInstalled() )
1011             {
1012               // SrcPackage is install-only
1013               SrcPackage::constPtr p = (*it)->asKind<SrcPackage>();
1014               installSrcPackage( p );
1015             }
1016
1017             it->status().resetTransact( ResStatus::USER );
1018           }
1019         }  // other resolvables
1020
1021       } // for
1022
1023       // Check presence of patch scripts. If aborting, at least log
1024       // omitted scripts.
1025       if ( ! successfullyInstalledPackages.empty() )
1026       {
1027         if ( ! RunUpdateScripts( _root, ZConfig::instance().update_scriptsPath(),
1028                                  successfullyInstalledPackages, abort ) )
1029         {
1030           WAR << "Commit aborted by the user" << endl;
1031           abort = true;
1032         }
1033       }
1034
1035       if ( abort )
1036       {
1037         ZYPP_THROW( TargetAbortedException( N_("Installation has been aborted as directed.") ) );
1038       }
1039
1040      return remaining;
1041     }
1042
1043     rpm::RpmDb & TargetImpl::rpm()
1044     {
1045       return _rpm;
1046     }
1047
1048     bool TargetImpl::providesFile (const std::string & path_str, const std::string & name_str) const
1049     {
1050       return _rpm.hasFile(path_str, name_str);
1051     }
1052
1053
1054     Date TargetImpl::timestamp() const
1055     {
1056       return _rpm.timestamp();
1057     }
1058
1059     ///////////////////////////////////////////////////////////////////
1060
1061     Product::constPtr TargetImpl::baseProduct() const
1062     {
1063       ResPool pool(ResPool::instance());
1064       for_( it, pool.byKindBegin<Product>(), pool.byKindEnd<Product>() )
1065       {
1066         Product::constPtr p = (*it)->asKind<Product>();
1067         if ( p->isTargetDistribution() )
1068           return p;
1069       }
1070       return 0L;
1071     }
1072
1073     namespace
1074     {
1075       parser::ProductFileData baseproductdata( const Pathname & root_r )
1076       {
1077         PathInfo baseproduct( Pathname::assertprefix( root_r, "/etc/products.d/baseproduct" ) );
1078         if ( baseproduct.isFile() )
1079         {
1080           try
1081           {
1082             return parser::ProductFileReader::scanFile( baseproduct.path() );
1083           }
1084           catch ( const Exception & excpt )
1085           {
1086             ZYPP_CAUGHT( excpt );
1087           }
1088         }
1089         return parser::ProductFileData();
1090       }
1091
1092     }
1093
1094     std::string TargetImpl::targetDistribution() const
1095     { return baseproductdata( _root ).registerTarget(); }
1096
1097     std::string TargetImpl::targetDistributionRelease() const
1098     { return baseproductdata( _root ).registerRelease(); }
1099
1100     std::string TargetImpl::distributionVersion() const
1101     {
1102       if ( _distributionVersion.empty() )
1103       {
1104         // By default ZYpp looks for /etc/product.d/baseproduct..
1105         //_distributionVersion = baseproductdata( _root ).edition().version();
1106
1107         if ( _distributionVersion.empty() )
1108         {
1109           // ...But the baseproduct method is not expected to work on RedHat derivatives.
1110           // On RHEL, Fedora and others the "product version" is determined by the first package
1111           // providing 'redhat-release'. This value is not hardcoded in YUM and can be configured
1112           // with the $distroverpkg variable.
1113           rpm::librpmDb::db_const_iterator it;
1114           if ( it.findByProvides( ZConfig::instance().distroverpkg() ) )
1115             _distributionVersion = it->tag_version();
1116         }
1117
1118         if ( !_distributionVersion.empty() )
1119           MIL << "Remember distributionVersion = '" << _distributionVersion << "'" << endl;
1120       }
1121       return _distributionVersion;
1122     }
1123
1124     std::string TargetImpl::distributionFlavor() const
1125     {
1126         std::ifstream idfile( ( home() / "LastDistributionFlavor" ).c_str() );
1127         for( iostr::EachLine in( idfile ); in; in.next() )
1128         {
1129             std::string line( str::trim( *in ) );
1130             if ( ! line.empty() )
1131                 return line;
1132         }
1133         return std::string();
1134     }
1135
1136     ///////////////////////////////////////////////////////////////////
1137
1138     std::string TargetImpl::anonymousUniqueId() const
1139     {
1140         std::ifstream idfile( ( home() / "AnonymousUniqueId" ).c_str() );
1141         for( iostr::EachLine in( idfile ); in; in.next() )
1142         {
1143             std::string line( str::trim( *in ) );
1144             if ( ! line.empty() )
1145                 return line;
1146         }
1147         return std::string();
1148     }
1149
1150     ///////////////////////////////////////////////////////////////////
1151
1152     void TargetImpl::installSrcPackage( const SrcPackage_constPtr & srcPackage_r )
1153     {
1154       // provide on local disk
1155       repo::RepoMediaAccess access_r;
1156       repo::SrcPackageProvider prov( access_r );
1157       ManagedFile localfile = prov.provideSrcPackage( srcPackage_r );
1158       // install it
1159       rpm().installPackage ( localfile );
1160     }
1161
1162     /////////////////////////////////////////////////////////////////
1163   } // namespace target
1164   ///////////////////////////////////////////////////////////////////
1165   /////////////////////////////////////////////////////////////////
1166 } // namespace zypp
1167 ///////////////////////////////////////////////////////////////////