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.isDir() )
 121     {
 122       DBG << "Adding fetcher cache: '" << cache_dir << "'." << endl;
 123       _caches.push_back(cache_dir);
 124     }
 125     else
 126     {
 127       // don't add bad cache directory, just log the error
 128       ERR << "Not adding cache: '" << cache_dir << "'. Not a directory." << endl;
 129     }
 130   }
 131
 132   void Fetcher::Impl::start( const Pathname &dest_dir,
 133                              MediaSetAccess &media,
 134                              const ProgressData::ReceiverFnc & progress_receiver )
 135   {
 136     ProgressData progress(_resources.size());
 137     progress.sendTo(progress_receiver);
 138
 139     for ( list<FetcherJob_Ptr>::const_iterator it_res = _resources.begin(); it_res != _resources.end(); ++it_res )
 140     {
 141       bool got_from_cache = false;
 142
 143       MIL << "start fetcher with " << _caches.size() << " cache directories." << endl;
 144       for_ ( it_cache, _caches.begin(), _caches.end() )
 145       {
 146         // does the current file exists in the current cache?
 147         Pathname cached_file = *it_cache + (*it_res)->location.filename();
 148
 149         if ( PathInfo( cached_file ).isExist() )
 150         {
 151           MIL << "File '" << cached_file << "' exist, testing checksum " << (*it_res)->location.checksum() << endl;
 152
 153           // check the checksum
 154           if ( is_checksum( cached_file, (*it_res)->location.checksum() ) && (! (*it_res)->location.checksum().empty() ) )
 155           {
 156             // cached
 157             MIL << "file " << (*it_res)->location.filename() << " found in previous cache. Using cached copy." << endl;
 158             // checksum is already checked.
 159             // we could later implement double failover and try to download if file copy fails.
 160
 161             // replicate the complete path in the target directory
 162             Pathname dest_full_path = dest_dir + (*it_res)->location.filename();
 163
 164             if( dest_full_path != cached_file )
 165             {
 166               if ( assert_dir( dest_full_path.dirname() ) != 0 )
 167                 ZYPP_THROW( Exception("Can't create " + dest_full_path.dirname().asString()));
 168
 169               if ( filesystem::hardlink(cached_file, dest_full_path ) != 0 )
 170               {
 171                 WAR << "Can't hardlink '" << cached_file << "' to '" << dest_dir << "'. Trying copying." << endl;
 172                 if ( filesystem::copy(cached_file, dest_full_path ) != 0 )
 173                 {
 174                   ERR << "Can't copy " << cached_file + " to " + dest_dir << endl;
 175                   // try next cache
 176                   continue;
 177                 }
 178               }
 179             }
 180
 181             got_from_cache = true;
 182             break;
 183           }
 184         }
 185       }
 186
 187       if ( ! got_from_cache )
 188       {
 189         MIL << "Not found in cache, downloading" << endl;
 190
 191         // try to get the file from the net
 192         try
 193         {
 194           Pathname tmp_file = media.provideFile((*it_res)->location);
 195           Pathname dest_full_path = dest_dir + (*it_res)->location.filename();
 196           if ( assert_dir( dest_full_path.dirname() ) != 0 )
 197                 ZYPP_THROW( Exception("Can't create " + dest_full_path.dirname().asString()));
 198           if ( filesystem::copy(tmp_file, dest_full_path ) != 0 )
 199           {
 200             ZYPP_THROW( Exception("Can't copy " + tmp_file.asString() + " to " + dest_dir.asString()));
 201           }
 202
 203
 204         }
 205         catch (const Exception & excpt_r)
 206         {
 207           ZYPP_CAUGHT(excpt_r);
 208           Exception nexcpt("Can't provide " + (*it_res)->location.filename().asString() + " : " + excpt_r.msg());
 209           nexcpt.remember(excpt_r);
 210           ZYPP_THROW(nexcpt);
 211         }
 212       }
 213       else
 214       {
 215         // We got the file from cache
 216         // continue with next file
 217         continue;
 218       }
 219
 220       // no matter where did we got the file, try to validate it:
 221       Pathname localfile = dest_dir + (*it_res)->location.filename();
 222       // call the checker function
 223       try {
 224         MIL << "Checking job [" << localfile << "] (" << (*it_res)->checkers.size() << " checkers )" << endl;
 225         for ( list<FileChecker>::const_iterator it = (*it_res)->checkers.begin();
 226               it != (*it_res)->checkers.end();
 227               ++it )
 228         {
 229           if (*it)
 230           {
 231             (*it)(localfile);
 232           }
 233           else
 234           {
 235             ERR << "Invalid checker for '" << localfile << "'" << endl;
 236           }
 237         }
 238
 239       }
 240       catch ( const FileCheckException &e )
 241       {
 242         ZYPP_RETHROW(e);
 243       }
 244       catch ( const Exception &e )
 245       {
 246         ZYPP_RETHROW(e);
 247       }
 248       catch (...)
 249       {
 250         ZYPP_THROW(Exception("Unknown error while validating " + (*it_res)->location.filename().asString()));
 251       }
 252
 253       if ( ! progress.incr() )
 254         ZYPP_THROW(AbortRequestException());
 255     } // for each job
 256   }
 257
 258   /** \relates Fetcher::Impl Stream output */
 259   inline std::ostream & operator<<( std::ostream & str, const Fetcher::Impl & obj )
 260   {
 261     return str << "Fetcher::Impl";
 262   }
 263
 264   ///////////////////////////////////////////////////////////////////
 265   //
 266   //    CLASS NAME : Fetcher
 267   //
 268   ///////////////////////////////////////////////////////////////////
 269
 270   ///////////////////////////////////////////////////////////////////
 271   //
 272   //    METHOD NAME : Fetcher::Fetcher
 273   //    METHOD TYPE : Ctor
 274   //
 275   Fetcher::Fetcher()
 276   : _pimpl( new Impl() )
 277   {}
 278
 279   ///////////////////////////////////////////////////////////////////
 280   //
 281   //    METHOD NAME : Fetcher::~Fetcher
 282   //    METHOD TYPE : Dtor
 283   //
 284   Fetcher::~Fetcher()
 285   {}
 286
 287   void Fetcher::enqueueDigested( const OnMediaLocation &resource, const FileChecker &checker )
 288   {
 289     _pimpl->enqueueDigested(resource, checker);
 290   }
 291
 292   void Fetcher::enqueue( const OnMediaLocation &resource, const FileChecker &checker  )
 293   {
 294     _pimpl->enqueue(resource, checker);
 295   }
 296
 297   void Fetcher::addCachePath( const Pathname &cache_dir )
 298   {
 299     _pimpl->addCachePath(cache_dir);
 300   }
 301
 302   void Fetcher::reset()
 303   {
 304     _pimpl->reset();
 305   }
 306
 307   void Fetcher::start( const Pathname &dest_dir,
 308                        MediaSetAccess &media,
 309                        const ProgressData::ReceiverFnc & progress_receiver )
 310   {
 311     _pimpl->start(dest_dir, media, progress_receiver);
 312   }
 313
 314
 315   /******************************************************************
 316   **
 317   **    FUNCTION NAME : operator<<
 318   **    FUNCTION TYPE : std::ostream &
 319   */
 320   std::ostream & operator<<( std::ostream & str, const Fetcher & obj )
 321   {
 322     return str << *obj._pimpl;
 323   }
 324
 325   /////////////////////////////////////////////////////////////////
 326 } // namespace zypp
 327 ///////////////////////////////////////////////////////////////////
 328