zypp/Fetcher.cc

   1 /*---------------------------------------------------------------------\
   2 |                          ____ _   __ __ ___                          |
   3 |                         |__  / \ / / . \ . \                         |
   4 |                           / / \ V /|  _/  _/                         |
   5 |                          / /__ | | | | | |                           |
   6 |                         /_____||_| |_| |_|                           |
   7 |                                                                      |
   8 \---------------------------------------------------------------------*/
   9 /** \file       zypp/Fetcher.cc
  10  *
  11 */
  12 #include <iostream>
  13 #include <list>
  14
  15 #include "zypp/base/Easy.h"
  16 #include "zypp/base/Logger.h"
  17 #include "zypp/base/PtrTypes.h"
  18 #include "zypp/base/DefaultIntegral.h"
  19 #include "zypp/Fetcher.h"
  20 #include "zypp/base/UserRequestException.h"
  21
  22 using namespace std;
  23
  24 ///////////////////////////////////////////////////////////////////
  25 namespace zypp
  26 { /////////////////////////////////////////////////////////////////
  27
  28   /**
  29    * Class to encapsulate the \ref OnMediaLocation object
  30    * and the \ref FileChecker together
  31    */
  32   struct FetcherJob
  33   {
  34     FetcherJob( const OnMediaLocation &loc )
  35       : location(loc)
  36     {
  37       //MIL << location << endl;
  38     }
  39
  40     ~FetcherJob()
  41     {
  42       //MIL << location << " | * " << checkers.size() << endl;
  43     }
  44
  45     OnMediaLocation location;
  46     //CompositeFileChecker checkers;
  47     list<FileChecker> checkers;
  48   };
  49
  50   typedef shared_ptr<FetcherJob> FetcherJob_Ptr;
  51
  52   ///////////////////////////////////////////////////////////////////
  53   //
  54   //    CLASS NAME : Fetcher::Impl
  55   //
  56   /** Fetcher implementation. */
  57   class Fetcher::Impl
  58   {
  59
  60   public:
  61     Impl() {}
  62     ~Impl() {
  63       MIL << endl;
  64      }
  65
  66     void enqueue( const OnMediaLocation &resource, const FileChecker &checker  );
  67     void enqueueDigested( const OnMediaLocation &resource, const FileChecker &checker );
  68     void addCachePath( const Pathname &cache_dir );
  69     void reset();
  70     void start( const Pathname &dest_dir,
  71                 MediaSetAccess &media,
  72                 const ProgressData::ReceiverFnc & progress_receiver );
  73
  74     /** Offer default Impl. */
  75     static shared_ptr<Impl> nullimpl()
  76     {
  77       static shared_ptr<Impl> _nullimpl( new Impl );
  78       return _nullimpl;
  79     }
  80
  81   private:
  82     friend Impl * rwcowClone<Impl>( const Impl * rhs );
  83     /** clone for RWCOW_pointer */
  84     Impl * clone() const
  85     { return new Impl( *this ); }
  86
  87     std::list<FetcherJob_Ptr> _resources;
  88     std::list<Pathname> _caches;
  89   };
  90   ///////////////////////////////////////////////////////////////////
  91
  92   void Fetcher::Impl::enqueueDigested( const OnMediaLocation &resource, const FileChecker &checker )
  93   {
  94     FetcherJob_Ptr job;
  95     job.reset(new FetcherJob(resource));
  96     ChecksumFileChecker digest_check(resource.checksum());
  97     job->checkers.push_back(digest_check);
  98     if ( checker )
  99       job->checkers.push_back(checker);
 100     _resources.push_back(job);
 101   }
 102
 103   void Fetcher::Impl::enqueue( const OnMediaLocation &resource, const FileChecker &checker )
 104   {
 105     FetcherJob_Ptr job;
 106     job.reset(new FetcherJob(resource));
 107     if ( checker )
 108       job->checkers.push_back(checker);
 109     _resources.push_back(job);
 110   }
 111
 112   void Fetcher::Impl::reset()
 113   {
 114     _resources.clear();
 115   }
 116
 117   void Fetcher::Impl::addCachePath( const Pathname &cache_dir )
 118   {
 119     PathInfo info(cache_dir);
 120     if ( info.isExist() )
 121     {
 122       if ( info.isDir() )
 123       {
 124         DBG << "Adding fetcher cache: '" << cache_dir << "'." << endl;
 125         _caches.push_back(cache_dir);
 126       }
 127       else
 128       {
 129         // don't add bad cache directory, just log the error
 130         ERR << "Not adding cache: '" << cache_dir << "'. Not a directory." << endl;
 131       }
 132     }
 133     else
 134     {
 135         ERR << "Not adding cache '" << cache_dir << "'. Path does not exists." << endl;
 136     }
 137
 138   }
 139
 140   void Fetcher::Impl::start( const Pathname &dest_dir,
 141                              MediaSetAccess &media,
 142                              const ProgressData::ReceiverFnc & progress_receiver )
 143   {
 144     ProgressData progress(_resources.size());
 145     progress.sendTo(progress_receiver);
 146
 147     for ( list<FetcherJob_Ptr>::const_iterator it_res = _resources.begin(); it_res != _resources.end(); ++it_res )
 148     {
 149       bool got_from_cache = false;
 150
 151       MIL << "start fetcher with " << _caches.size() << " cache directories." << endl;
 152       for_ ( it_cache, _caches.begin(), _caches.end() )
 153       {
 154         // does the current file exists in the current cache?
 155         Pathname cached_file = *it_cache + (*it_res)->location.filename();
 156
 157         if ( PathInfo( cached_file ).isExist() )
 158         {
 159           DBG << "File '" << cached_file << "' exist, testing checksum " << (*it_res)->location.checksum() << endl;
 160
 161           // check the checksum
 162           if ( is_checksum( cached_file, (*it_res)->location.checksum() ) && (! (*it_res)->location.checksum().empty() ) )
 163           {
 164             // cached
 165             MIL << "file " << (*it_res)->location.filename() << " found in previous cache. Using cached copy." << endl;
 166             // checksum is already checked.
 167             // we could later implement double failover and try to download if file copy fails.
 168
 169             // replicate the complete path in the target directory
 170             Pathname dest_full_path = dest_dir + (*it_res)->location.filename();
 171
 172             if( dest_full_path != cached_file )
 173             {
 174               if ( assert_dir( dest_full_path.dirname() ) != 0 )
 175                 ZYPP_THROW( Exception("Can't create " + dest_full_path.dirname().asString()));
 176
 177               if ( filesystem::hardlink(cached_file, dest_full_path ) != 0 )
 178               {
 179                 WAR << "Can't hardlink '" << cached_file << "' to '" << dest_dir << "'. Trying copying." << endl;
 180                 if ( filesystem::copy(cached_file, dest_full_path ) != 0 )
 181                 {
 182                   ERR << "Can't copy " << cached_file + " to " + dest_dir << endl;
 183                   // try next cache
 184                   continue;
 185                 }
 186               }
 187             }
 188
 189             got_from_cache = true;
 190             break;
 191           }
 192         }
 193       }
 194
 195       if ( ! got_from_cache )
 196       {
 197         MIL << "Not found in cache, downloading" << endl;
 198
 199         // try to get the file from the net
 200         try
 201         {
 202           Pathname tmp_file = media.provideFile((*it_res)->location);
 203           Pathname dest_full_path = dest_dir + (*it_res)->location.filename();
 204           if ( assert_dir( dest_full_path.dirname() ) != 0 )
 205                 ZYPP_THROW( Exception("Can't create " + dest_full_path.dirname().asString()));
 206           if ( filesystem::copy(tmp_file, dest_full_path ) != 0 )
 207           {
 208             ZYPP_THROW( Exception("Can't copy " + tmp_file.asString() + " to " + dest_dir.asString()));
 209           }
 210
 211
 212         }
 213         catch (const Exception & excpt_r)
 214         {
 215           ZYPP_CAUGHT(excpt_r);
 216           Exception nexcpt("Can't provide " + (*it_res)->location.filename().asString() + " : " + excpt_r.msg());
 217           nexcpt.remember(excpt_r);
 218           ZYPP_THROW(nexcpt);
 219         }
 220       }
 221       else
 222       {
 223         // We got the file from cache
 224         // continue with next file
 225         continue;
 226       }
 227
 228       // no matter where did we got the file, try to validate it:
 229       Pathname localfile = dest_dir + (*it_res)->location.filename();
 230       // call the checker function
 231       try {
 232         MIL << "Checking job [" << localfile << "] (" << (*it_res)->checkers.size() << " checkers )" << endl;
 233         for ( list<FileChecker>::const_iterator it = (*it_res)->checkers.begin();
 234               it != (*it_res)->checkers.end();
 235               ++it )
 236         {
 237           if (*it)
 238           {
 239             (*it)(localfile);
 240           }
 241           else
 242           {
 243             ERR << "Invalid checker for '" << localfile << "'" << endl;
 244           }
 245         }
 246
 247       }
 248       catch ( const FileCheckException &e )
 249       {
 250         ZYPP_RETHROW(e);
 251       }
 252       catch ( const Exception &e )
 253       {
 254         ZYPP_RETHROW(e);
 255       }
 256       catch (...)
 257       {
 258         ZYPP_THROW(Exception("Unknown error while validating " + (*it_res)->location.filename().asString()));
 259       }
 260
 261       if ( ! progress.incr() )
 262         ZYPP_THROW(AbortRequestException());
 263     } // for each job
 264   }
 265
 266   /** \relates Fetcher::Impl Stream output */
 267   inline std::ostream & operator<<( std::ostream & str, const Fetcher::Impl & obj )
 268   {
 269     return str << "Fetcher::Impl";
 270   }
 271
 272   ///////////////////////////////////////////////////////////////////
 273   //
 274   //    CLASS NAME : Fetcher
 275   //
 276   ///////////////////////////////////////////////////////////////////
 277
 278   ///////////////////////////////////////////////////////////////////
 279   //
 280   //    METHOD NAME : Fetcher::Fetcher
 281   //    METHOD TYPE : Ctor
 282   //
 283   Fetcher::Fetcher()
 284   : _pimpl( new Impl() )
 285   {}
 286
 287   ///////////////////////////////////////////////////////////////////
 288   //
 289   //    METHOD NAME : Fetcher::~Fetcher
 290   //    METHOD TYPE : Dtor
 291   //
 292   Fetcher::~Fetcher()
 293   {}
 294
 295   void Fetcher::enqueueDigested( const OnMediaLocation &resource, const FileChecker &checker )
 296   {
 297     _pimpl->enqueueDigested(resource, checker);
 298   }
 299
 300   void Fetcher::enqueue( const OnMediaLocation &resource, const FileChecker &checker  )
 301   {
 302     _pimpl->enqueue(resource, checker);
 303   }
 304
 305   void Fetcher::addCachePath( const Pathname &cache_dir )
 306   {
 307     _pimpl->addCachePath(cache_dir);
 308   }
 309
 310   void Fetcher::reset()
 311   {
 312     _pimpl->reset();
 313   }
 314
 315   void Fetcher::start( const Pathname &dest_dir,
 316                        MediaSetAccess &media,
 317                        const ProgressData::ReceiverFnc & progress_receiver )
 318   {
 319     _pimpl->start(dest_dir, media, progress_receiver);
 320   }
 321
 322
 323   /******************************************************************
 324   **
 325   **    FUNCTION NAME : operator<<
 326   **    FUNCTION TYPE : std::ostream &
 327   */
 328   std::ostream & operator<<( std::ostream & str, const Fetcher & obj )
 329   {
 330     return str << *obj._pimpl;
 331   }
 332
 333   /////////////////////////////////////////////////////////////////
 334 } // namespace zypp
 335 ///////////////////////////////////////////////////////////////////
 336