zypp/repo/PackageProvider.cc

   1 /*---------------------------------------------------------------------\
   2 |                          ____ _   __ __ ___                          |
   3 |                         |__  / \ / / . \ . \                         |
   4 |                           / / \ V /|  _/  _/                         |
   5 |                          / /__ | | | | | |                           |
   6 |                         /_____||_| |_| |_|                           |
   7 |                                                                      |
   8 \---------------------------------------------------------------------*/
   9 /** \file       zypp/repo/PackageProvider.cc
  10  *
  11 */
  12 #include <iostream>
  13 #include <sstream>
  14 #include "zypp/repo/PackageDelta.h"
  15 #include "zypp/base/Logger.h"
  16 #include "zypp/base/Gettext.h"
  17 #include "zypp/base/UserRequestException.h"
  18 #include "zypp/repo/PackageProvider.h"
  19 #include "zypp/repo/RepoProvideFile.h"
  20 #include "zypp/repo/Applydeltarpm.h"
  21 #include "zypp/repo/PackageDelta.h"
  22
  23 #include "zypp/TmpPath.h"
  24 #include "zypp/ZConfig.h"
  25 #include "zypp/RepoInfo.h"
  26 #include "zypp/media/MediaManager.h"
  27
  28 using std::endl;
  29 using zypp::media::MediaManager;
  30
  31 ///////////////////////////////////////////////////////////////////
  32 namespace zypp
  33 { /////////////////////////////////////////////////////////////////
  34   ///////////////////////////////////////////////////////////////////
  35   namespace repo
  36   { /////////////////////////////////////////////////////////////////
  37
  38     ///////////////////////////////////////////////////////////////////
  39     //
  40     //  CLASS NAME : PackageProviderPolicy
  41     //
  42     ///////////////////////////////////////////////////////////////////
  43
  44     bool PackageProviderPolicy::queryInstalled( const std::string & name_r,
  45                                                 const Edition &     ed_r,
  46                                                 const Arch &        arch_r ) const
  47     {
  48       if ( _queryInstalledCB )
  49         return _queryInstalledCB( name_r, ed_r, arch_r );
  50       return false;
  51     }
  52
  53     ///////////////////////////////////////////////////////////////////
  54     //
  55     //  CLASS NAME : PackageProvider
  56     //
  57     ///////////////////////////////////////////////////////////////////
  58
  59     ///////////////////////////////////////////////////////////////////
  60     namespace
  61     { /////////////////////////////////////////////////////////////////
  62
  63       inline std::string defRpmFileName( const Package::constPtr & package )
  64       {
  65         std::ostringstream ret;
  66         ret << package->name() << '-' << package->edition() << '.' << package->arch() << ".rpm";
  67         return ret.str();
  68       }
  69
  70       /////////////////////////////////////////////////////////////////
  71     } // namespace source
  72     ///////////////////////////////////////////////////////////////////
  73     PackageProvider::PackageProvider(  RepoMediaAccess &access,
  74                                       const Package::constPtr & package,
  75                                       const DeltaCandidates & deltas,
  76                                       const PackageProviderPolicy & policy_r )
  77     : _policy( policy_r )
  78     , _package( package )
  79     , _deltas(deltas)
  80     , _access(access)
  81     {}
  82
  83     PackageProvider::~PackageProvider()
  84     {}
  85
  86     ManagedFile PackageProvider::providePackage() const
  87     {
  88       Url url;
  89       RepoInfo info = _package->repoInfo();
  90       // FIXME we only support the first url for now.
  91       if ( info.baseUrlsEmpty() )
  92         ZYPP_THROW(Exception("No url in repository."));
  93       else
  94         url = * info.baseUrlsBegin();
  95
  96       MIL << "provide Package " << _package << endl;
  97       ScopedGuard guardReport( newReport() );
  98       ManagedFile ret;
  99       do {
 100         _retry = false;
 101         report()->start( _package, url );
 102         try  // ELIMINATE try/catch by providing a log-guard
 103           {
 104             ret = doProvidePackage();
 105           }
 106         catch ( const Exception & excpt )
 107           {
 108             ERR << "Failed to provide Package " << _package << endl;
 109             if ( ! _retry )
 110               {
 111                 ZYPP_RETHROW( excpt );
 112               }
 113           }
 114       } while ( _retry );
 115
 116       report()->finish( _package, repo::DownloadResolvableReport::NO_ERROR, std::string() );
 117       MIL << "provided Package " << _package << " at " << ret << endl;
 118       return ret;
 119     }
 120
 121     ManagedFile PackageProvider::doProvidePackage() const
 122     {
 123       Url url;
 124       RepoInfo info = _package->repoInfo();
 125       // FIXME we only support the first url for now.
 126       if ( info.baseUrlsEmpty() )
 127         ZYPP_THROW(Exception("No url in repository."));
 128       else
 129         url = * info.baseUrlsBegin();
 130
 131       // check whether to process patch/delta rpms
 132       if ( MediaManager::downloads(url) || ZConfig::instance().download_use_deltarpm_always() )
 133         {
 134           std::list<DeltaRpm> deltaRpms;
 135           if ( ZConfig::instance().download_use_deltarpm() )
 136           {
 137             _deltas.deltaRpms( _package ).swap( deltaRpms );
 138           }
 139
 140           if ( ! ( deltaRpms.empty() )
 141                && queryInstalled() )
 142             {
 143               if ( ! deltaRpms.empty() && applydeltarpm::haveApplydeltarpm() )
 144                 {
 145                   for( std::list<DeltaRpm>::const_iterator it = deltaRpms.begin();
 146                        it != deltaRpms.end(); ++it )
 147                     {
 148                       DBG << "tryDelta " << *it << endl;
 149                       ManagedFile ret( tryDelta( *it ) );
 150                       if ( ! ret->empty() )
 151                         return ret;
 152                     }
 153                 }
 154             }
 155         }
 156
 157       // no patch/delta -> provide full package
 158       ManagedFile ret;
 159       OnMediaLocation loc = _package->location();
 160
 161       ProvideFilePolicy policy;
 162       policy.progressCB( bind( &PackageProvider::progressPackageDownload, this, _1 ) );
 163       policy.failOnChecksumErrorCB( bind( &PackageProvider::failOnChecksumError, this ) );
 164       return _access.provideFile( _package->repoInfo(), loc, policy );
 165     }
 166
 167     ManagedFile PackageProvider::tryDelta( const DeltaRpm & delta_r ) const
 168     {
 169       if ( delta_r.baseversion().edition() != Edition::noedition
 170            && ! queryInstalled( delta_r.baseversion().edition() ) )
 171         return ManagedFile();
 172
 173       if ( ! applydeltarpm::quickcheck( delta_r.baseversion().sequenceinfo() ) )
 174         return ManagedFile();
 175
 176       report()->startDeltaDownload( delta_r.location().filename(),
 177                                     delta_r.location().downloadSize() );
 178       ManagedFile delta;
 179       try
 180         {
 181           ProvideFilePolicy policy;
 182           policy.progressCB( bind( &PackageProvider::progressDeltaDownload, this, _1 ) );
 183           delta = _access.provideFile( delta_r.repository().info(), delta_r.location(), policy );
 184         }
 185       catch ( const Exception & excpt )
 186         {
 187           report()->problemDeltaDownload( excpt.asUserString() );
 188           return ManagedFile();
 189         }
 190       report()->finishDeltaDownload();
 191
 192       report()->startDeltaApply( delta );
 193       if ( ! applydeltarpm::check( delta_r.baseversion().sequenceinfo() ) )
 194         {
 195           report()->problemDeltaApply( _("applydeltarpm check failed.") );
 196           return ManagedFile();
 197         }
 198
 199       Pathname destination( Pathname::dirname( delta ) / defRpmFileName( _package ) );
 200
 201       if ( ! delta.getDispose() )
 202       {
 203         // There is no cleanup method associated with the deta. Thus the
 204         // delta is not a temporary file, and we don't want to write in
 205         // the package into this directory.
 206         destination = filesystem::TmpPath::defaultLocation() / defRpmFileName( _package );
 207       }
 208
 209       if ( ! applydeltarpm::provide( delta, destination,
 210                                      bind( &PackageProvider::progressDeltaApply, this, _1 ) ) )
 211         {
 212           report()->problemDeltaApply( _("applydeltarpm failed.") );
 213           return ManagedFile();
 214         }
 215       report()->finishDeltaApply();
 216
 217       return ManagedFile( destination, filesystem::unlink );
 218     }
 219
 220     PackageProvider::ScopedGuard PackageProvider::newReport() const
 221     {
 222       _report.reset( new Report );
 223       return shared_ptr<void>( static_cast<void*>(0),
 224                                // custom deleter calling _report.reset()
 225                                // (cast required as reset is overloaded)
 226                                bind( mem_fun_ref( static_cast<void (shared_ptr<Report>::*)()>(&shared_ptr<Report>::reset) ),
 227                                      ref(_report) ) );
 228     }
 229
 230     PackageProvider::Report & PackageProvider::report() const
 231     { return *_report; }
 232
 233     bool PackageProvider::progressDeltaDownload( int value ) const
 234     { return report()->progressDeltaDownload( value ); }
 235
 236     void PackageProvider::progressDeltaApply( int value ) const
 237     { return report()->progressDeltaApply( value ); }
 238
 239     bool PackageProvider::progressPackageDownload( int value ) const
 240     { return report()->progress( value, _package ); }
 241
 242     bool PackageProvider::failOnChecksumError() const
 243     {
 244       std::string package_str = _package->name() + "-" + _package->edition().asString();
 245
 246       // TranslatorExplanation %s = package being checked for integrity
 247       switch ( report()->problem( _package, repo::DownloadResolvableReport::INVALID, str::form(_("Package %s seems to be corrupted during transfer. Do you want to retry retrieval?"), package_str.c_str() ) ) )
 248         {
 249         case repo::DownloadResolvableReport::RETRY:
 250           _retry = true;
 251           break;
 252           case repo::DownloadResolvableReport::IGNORE:
 253           ZYPP_THROW(SkipRequestException("User requested skip of corrupted file"));
 254           break;
 255           case repo::DownloadResolvableReport::ABORT:
 256           ZYPP_THROW(AbortRequestException("User requested to abort"));
 257           break;
 258         default:
 259           break;
 260         }
 261       return true; // anyway a failure
 262     }
 263
 264     bool PackageProvider::queryInstalled( const Edition & ed_r ) const
 265     { return _policy.queryInstalled( _package->name(), ed_r, _package->arch() ); }
 266
 267
 268     /////////////////////////////////////////////////////////////////
 269   } // namespace repo
 270   ///////////////////////////////////////////////////////////////////
 271   /////////////////////////////////////////////////////////////////
 272 } // namespace zypp
 273 ///////////////////////////////////////////////////////////////////