libzypp  17.31.8
MediaNetwork.cc
Go to the documentation of this file.
1 /*---------------------------------------------------------------------\
2 | ____ _ __ __ ___ |
3 | |__ / \ / / . \ . \ |
4 | / / \ V /| _/ _/ |
5 | / /__ | | | | | | |
6 | /_____||_| |_| |_| |
7 | |
8 \---------------------------------------------------------------------*/
13 #include <iostream>
14 #include <list>
15 #include <chrono>
16 
17 #include <zypp/base/Logger.h>
18 #include <zypp/base/String.h>
19 #include <zypp/base/Gettext.h>
20 
21 #include <zypp-core/base/Regex.h>
22 #include <zypp-core/fs/TmpPath.h>
23 #include <zypp-core/zyppng/base/EventDispatcher>
24 #include <zypp-core/zyppng/base/EventLoop>
25 #include <zypp-core/zyppng/base/private/threaddata_p.h>
26 
27 #include <zypp-curl/ng/network/Downloader>
28 #include <zypp-curl/ng/network/NetworkRequestDispatcher>
29 #include <zypp-curl/ng/network/DownloadSpec>
30 
31 #include <zypp-media/MediaConfig>
33 #include <zypp-media/auth/CredentialManager>
34 
35 #include <zypp/Target.h>
36 #include <zypp/ZConfig.h>
37 
38 
39 using std::endl;
40 
41 namespace internal {
42 
43 
44  constexpr std::string_view MEDIACACHE_REGEX("^\\/media\\.[1-9][0-9]*\\/media$");
45 
46  struct ProgressTracker {
47 
48  using clock = std::chrono::steady_clock;
49 
50  std::optional<clock::time_point> _timeStart;
51  std::optional<clock::time_point> _timeLast;
52 
53  double _dnlTotal = 0.0;
54  double _dnlLast = 0.0;
55  double _dnlNow = 0.0;
56 
57  int _dnlPercent= 0;
58 
59  double _drateTotal= 0.0;
60  double _drateLast = 0.0;
61 
62  void updateStats( double dltotal = 0.0, double dlnow = 0.0 )
63  {
64  clock::time_point now = clock::now();
65 
66  if ( !_timeStart )
67  _timeStart = _timeLast = now;
68 
69  // If called without args (0.0), recompute based on the last values seen
70  if ( dltotal && dltotal != _dnlTotal )
71  _dnlTotal = dltotal;
72 
73  if ( dlnow && dlnow != _dnlNow ) {
74  _dnlNow = dlnow;
75  }
76 
77  // percentage:
78  if ( _dnlTotal )
79  _dnlPercent = int(_dnlNow * 100 / _dnlTotal);
80 
81  // download rates:
82  _drateTotal = _dnlNow / std::max( std::chrono::duration_cast<std::chrono::seconds>(now - *_timeStart).count(), int64_t(1) );
83 
84  if ( _timeLast < now )
85  {
86  _drateLast = (_dnlNow - _dnlLast) / int( std::chrono::duration_cast<std::chrono::seconds>(now - *_timeLast).count() );
87  // start new period
88  _timeLast = now;
89  _dnlLast = _dnlNow;
90  }
91  else if ( _timeStart == _timeLast )
93  }
94  };
95 
96 
97  // All media handler instances share the same EventDispatcher and Downloader
98  // This is released at application shutdown.
99  struct SharedData {
100 
102  MIL << "Releasing internal::SharedData for MediaNetwork." << std::endl;
103  }
104 
105  static std::shared_ptr<SharedData> instance () {
106  static std::shared_ptr<SharedData> data = std::shared_ptr<SharedData>( new SharedData() );
107  return data;
108  }
109 
110  static const zypp::str::regex &mediaRegex () {
111  static zypp::str::regex reg( MEDIACACHE_REGEX.data() );
112  return reg;
113  }
114 
115  // we need to keep a reference
116  zyppng::EventDispatcherRef _dispatcher;
117  zyppng::DownloaderRef _downloader;
118 
120 
121  MediaFileCacheEntry( zypp::ManagedFile &&file ) : _file( std::move(file) ) { }
122 
123  std::chrono::steady_clock::time_point _creationTime = std::chrono::steady_clock::now();
125  };
126 
127  auto findInCache( const std::string &mediaCacheKey ) {
128  auto i = _mediaCacheEntries.find( mediaCacheKey );
129  if ( i != _mediaCacheEntries.end() ) {
130  auto age = std::chrono::steady_clock::now() - i->second._creationTime;
131  if ( age > std::chrono::minutes( 30 ) ) {
132  MIL << "Found cached media file, but it's older than 30 mins, requesting a new one" << std::endl;
133  _mediaCacheEntries.erase(i);
134  } else {
135  return i;
136  }
137  }
138  return _mediaCacheEntries.end();
139  }
140 
142  std::unordered_map<std::string, MediaFileCacheEntry> _mediaCacheEntries;
143 
144  private:
146  MIL << "Initializing internal::SharedData for MediaNetwork" << std::endl;
147  _dispatcher = zyppng::ThreadData::current().ensureDispatcher();
148  _downloader = std::make_shared<zyppng::Downloader>();
149  _downloader->requestDispatcher()->setMaximumConcurrentConnections( zypp::MediaConfig::instance().download_max_concurrent_connections() );
150  }
151  };
152 
153 }
154 
155 using namespace internal;
156 using namespace zypp::base;
157 
158 namespace zypp {
159 
160  namespace media {
161 
162  MediaNetwork::MediaNetwork( const Url & url_r,
163  const Pathname & attach_point_hint_r )
164  : MediaNetworkCommonHandler( url_r, attach_point_hint_r,
165  "/", // urlpath at attachpoint
166  true ) // does_download
167  {
168  MIL << "MediaNetwork::MediaNetwork(" << url_r << ", " << attach_point_hint_r << ")" << endl;
169 
170  // make sure there is a event loop and downloader instance
172 
173  if( !attachPoint().empty())
174  {
175  PathInfo ainfo(attachPoint());
176  Pathname apath(attachPoint() + "XXXXXX");
177  char *atemp = ::strdup( apath.asString().c_str());
178  char *atest = NULL;
179  if( !ainfo.isDir() || !ainfo.userMayRWX() ||
180  atemp == NULL || (atest=::mkdtemp(atemp)) == NULL)
181  {
182  WAR << "attach point " << ainfo.path()
183  << " is not useable for " << url_r.getScheme() << endl;
184  setAttachPoint("", true);
185  }
186  else if( atest != NULL)
187  ::rmdir(atest);
188 
189  if( atemp != NULL)
190  ::free(atemp);
191  }
192  }
193 
194  void MediaNetwork::attachTo (bool next)
195  {
196  if ( next )
198 
199  if ( !_url.isValid() )
201 
202  // use networkdispatcher check if the scheme is supported
203  if ( !_shared->_downloader->requestDispatcher()->supportsProtocol( _url ) ) {
204  std::string msg("Unsupported protocol '");
205  msg += _url.getScheme();
206  msg += "'";
208  }
209 
211  {
213  }
214 
215  disconnectFrom();
216 
218  setMediaSource(media);
219  }
220 
221  bool
223  {
224  return MediaHandler::checkAttachPoint( apoint, true, true);
225  }
226 
228  {
229  }
230 
231  void MediaNetwork::releaseFrom( const std::string & ejectDev )
232  {
233  disconnect();
234  }
235 
237  {
238  auto ev = zyppng::EventLoop::create();
239  std::vector<zyppng::connection> signalConnections;
240  OnScopeExit deferred([&](){
241  while( signalConnections.size() ) {
242  signalConnections.back().disconnect();
243  signalConnections.pop_back();
244  }
245  });
246 
247  zyppng::DownloadRef dl = _shared->_downloader->downloadFile( spec );
248  std::optional<internal::ProgressTracker> progTracker;
249 
250  const auto &startedSlot = [&]( zyppng::Download &req ){
251  if ( !report) return;
252  (*report)->start( spec.url(), spec.targetPath());
253  };
254 
255  const auto &aliveSlot = [&]( zyppng::Download &req, off_t dlNow ){
256  if ( !report || !progTracker )
257  return;
258  progTracker->updateStats( 0.0, dlNow );
259  if ( !(*report)->progress( progTracker->_dnlPercent, spec.url(), progTracker-> _drateTotal, progTracker->_drateLast ) )
260  req.cancel();
261  };
262 
263  const auto &progressSlot = [&]( zyppng::Download &req, off_t dlTotal, off_t dlNow ) {
264  if ( !report || !progTracker )
265  return;
266 
267  progTracker->updateStats( dlTotal, dlNow );
268  if ( !(*report)->progress( progTracker->_dnlPercent, spec.url(), progTracker-> _drateTotal, progTracker->_drateLast ) )
269  req.cancel();
270  };
271 
272  const auto &finishedSlot = [&]( zyppng::Download & ){
273  ev->quit();
274  };
275 
276  bool firstTry = true;
277  const auto &authRequiredSlot = [&]( zyppng::Download &req, zyppng::NetworkAuthData &auth, const std::string &availAuth ){
278 
280  CredentialManager cm(CredManagerOptions(ZConfig::instance().repoManagerRoot()));
281  CurlAuthData_Ptr credentials;
282 
283  // get stored credentials
284  AuthData_Ptr cmcred = cm.getCred(_url);
285  if ( cmcred && auth.lastDatabaseUpdate() < cmcred->lastDatabaseUpdate() ) {
286  credentials.reset(new CurlAuthData(*cmcred));
287  DBG << "got stored credentials:" << endl << *credentials << endl;
288 
289  } else {
290  // if not found, ask user
291  CurlAuthData_Ptr curlcred;
292  curlcred.reset(new CurlAuthData());
294 
295  // preset the username if present in current url
296  if (!_url.getUsername().empty() && firstTry)
297  curlcred->setUsername(_url.getUsername());
298  // if CM has found some credentials, preset the username from there
299  else if (cmcred)
300  curlcred->setUsername(cmcred->username());
301 
302  // indicate we have no good credentials from CM
303  cmcred.reset();
304 
305  std::string prompt_msg = str::Format(_("Authentication required for '%s'")) % _url.asString();
306 
307  // set available authentication types from the signal
308  // might be needed in prompt
309  curlcred->setAuthType( availAuth );
310 
311  // ask user
312  if (auth_report->prompt(_url, prompt_msg, *curlcred))
313  {
314  DBG << "callback answer: retry" << endl
315  << "CurlAuthData: " << *curlcred << endl;
316 
317  if (curlcred->valid())
318  {
319  credentials = curlcred;
320  // if (credentials->username() != _url.getUsername())
321  // _url.setUsername(credentials->username());
329  }
330  }
331  else
332  {
333  DBG << "callback answer: cancel" << endl;
334  }
335  }
336 
337  if ( !credentials ) {
338  auth = zyppng::NetworkAuthData();
339  return;
340  }
341 
342  auth = *credentials;
343  if (!cmcred) {
344  credentials->setUrl(_url);
345  cm.addCred(*credentials);
346  cm.save();
347  }
348  };
349 
350  signalConnections.insert( signalConnections.end(), {
351  dl->connectFunc( &zyppng::Download::sigStarted, startedSlot),
352  dl->connectFunc( &zyppng::Download::sigFinished, finishedSlot ),
353  dl->connectFunc( &zyppng::Download::sigAuthRequired, authRequiredSlot )
354  });
355 
356  if ( report ) {
357  progTracker = internal::ProgressTracker();
358  signalConnections.insert( signalConnections.end(), {
359  dl->connectFunc( &zyppng::Download::sigAlive, aliveSlot ),
360  dl->connectFunc( &zyppng::Download::sigProgress, progressSlot ),
361  });
362  }
363 
364  dl->start();
365  ev->run();
366 
367  std::for_each( signalConnections.begin(), signalConnections.end(), []( auto &conn ) { conn.disconnect(); });
368 
369  if ( dl->hasError() ) {
371  std::exception_ptr excp;
372  const auto &error = dl->lastRequestError();
373  switch ( error.type() ) {
383  excp = ZYPP_EXCPT_PTR( zypp::media::MediaCurlException( spec.url(), error.toString(), error.nativeErrorString() ) );
384  break;
385  }
387  excp = ZYPP_EXCPT_PTR( zypp::media::MediaRequestCancelledException( error.toString() ) );
388  break;
389  }
392  break;
393  }
395  excp = ZYPP_EXCPT_PTR( zypp::media::MediaTemporaryProblemException( spec.url(), error.toString() ) );
396  break;
397  }
399  excp = ZYPP_EXCPT_PTR( zypp::media::MediaTimeoutException( spec.url(), error.toString() ) );
400  break;
401  }
403  excp = ZYPP_EXCPT_PTR( zypp::media::MediaForbiddenException( spec.url(), error.toString() ) );
404  break;
405  }
408 
409  //@BUG using getPathName() can result in wrong error messages
411  break;
412  }
416  excp = ZYPP_EXCPT_PTR( zypp::media::MediaUnauthorizedException( spec.url(), error.toString(), error.nativeErrorString(), "" ) );
417  break;
418  }
420  // should never happen
421  DBG << "BUG: Download error flag is set , but Error code is NoError" << std::endl;
422  break;
423  }
424 
425  if ( excp ) {
426  if ( report ) (*report)->finish( spec.url(), errCode, error.toString() );
427  std::rethrow_exception( excp );
428  }
429  }
430  if ( report ) (*report)->finish( spec.url(), zypp::media::DownloadProgressReport::NO_ERROR, "" );
431  }
432 
433  void MediaNetwork::getFile( const OnMediaLocation &file ) const
434  {
435  // Use absolute file name to prevent access of files outside of the
436  // hierarchy below the attach point.
437  getFileCopy( file, localPath(file.filename()).absolutename() );
438  }
439 
440  void MediaNetwork::getFileCopy( const OnMediaLocation & file, const Pathname & targetFilename ) const
441  {
442  const auto &filename = file.filename();
443  Url fileurl(getFileUrl(filename));
444 
445  const bool requestedMediaFile = _shared->mediaRegex().matches( filename.asString() );
446  auto &mediaFileCache = _shared->_mediaCacheEntries;
447  const auto &mediaCacheKey = fileurl.asCompleteString();
448 
449  DBG << "FILEURL IS: " << fileurl << std::endl;
450  DBG << "Downloading to: " << targetFilename << std::endl;
451 
452  if( assert_dir( targetFilename.dirname() ) ) {
453  DBG << "assert_dir " << targetFilename.dirname() << " failed" << endl;
454  ZYPP_THROW( MediaSystemException(getFileUrl(file.filename()), "System error on " + targetFilename.dirname().asString()) );
455  }
456 
457  if ( requestedMediaFile ) {
458  MIL << "Requested " << filename << " trying media cache first" << std::endl;
459 
460  auto i = _shared->findInCache( mediaCacheKey );
461  if ( i != mediaFileCache.end() ) {
462  MIL << "Found cached media file, returning a copy to the file" << std::endl;
463  if ( zypp::filesystem::hardlinkCopy( i->second._file, targetFilename ) == 0 )
464  return;
465 
466  mediaFileCache.erase(i);
467  MIL << "Failed to copy the requested file, proceeding with download" << std::endl;
468  }
469 
470  MIL << "Nothing in the file cache, requesting the file from the server." << std::endl;
471  }
472 
473  zyppng::DownloadSpec spec = zyppng::DownloadSpec( fileurl, targetFilename, file.downloadSize() )
474  .setDeltaFile( file.deltafile() )
475  .setHeaderSize( file.headerSize())
476  .setHeaderChecksum( file.headerChecksum() )
477  .setTransferSettings( this->_settings );
478 
480 
481  try {
482  runRequest( spec, &report );
483  } catch ( const zypp::media::MediaFileNotFoundException &ex ) {
484  if ( requestedMediaFile ) {
485  MIL << "Media file was not found, remembering in the cache" << std::endl;
486  mediaFileCache.insert_or_assign( mediaCacheKey, internal::SharedData::MediaFileCacheEntry( zypp::ManagedFile() ) );
487  }
488  std::rethrow_exception( std::current_exception() );
489  }
490 
491  // the request was successful
492  if ( requestedMediaFile ) {
493  const auto &cacheFileName = (_shared->_mediaCacheDir.path() / zypp::CheckSum::md5FromString( mediaCacheKey).asString() ).extend(".cache");
494  zypp::ManagedFile file( cacheFileName, zypp::filesystem::unlink );
495  if ( zypp::filesystem::hardlinkCopy( targetFilename, cacheFileName ) == 0 ) {
496  mediaFileCache.insert_or_assign( mediaCacheKey, internal::SharedData::MediaFileCacheEntry( std::move(file) ) );
497  MIL << "Saved requested media file in media cache for future use" << std::endl;
498  } else {
499  MIL << "Failed to save requested media file in cache, requesting again next time." << std::endl;
500  }
501  }
502  }
503 
504  bool MediaNetwork::getDoesFileExist( const Pathname & filename ) const
505  {
506  MIL << "Checking if file " << filename << " does exist" << std::endl;
507  Url fileurl(getFileUrl(filename));
508  const bool requestMediaFile = _shared->mediaRegex().matches( filename.asString() );
509  auto &mediaFileCache = _shared->_mediaCacheEntries;
510  const auto &mediaCacheKey = fileurl.asCompleteString();
511 
512  if ( requestMediaFile ) {
513  MIL << "Request for " << filename << " is a media file, trying the cache first" << std::endl;
514  auto i = _shared->findInCache( mediaCacheKey );
515  if ( i != mediaFileCache.end() ) {
516  MIL << "Found a cache entry for requested media file, returning right away" << std::endl;
517  if ( i->second._file->empty() ) {
518  return false;
519  } else {
520  return true;
521  }
522  }
523  }
524 
525  bool result = false; //we are pessimists
526  try
527  {
528  const auto &targetFilePath = localPath(filename).absolutename();
529 
530  zyppng::DownloadSpec spec = zyppng::DownloadSpec( fileurl, targetFilePath )
531  .setCheckExistsOnly( true )
532  .setTransferSettings( this->_settings );
533 
534  runRequest( spec );
535  // if we get to here the request worked.
536  result = true;
537  }
538  catch ( const MediaFileNotFoundException &e ) {
539  // if the file did not exist then we can return false
540  ZYPP_CAUGHT(e);
541  result = false;
542  }
543  // unexpected exception
544  catch (MediaException & excpt_r)
545  {
546  ZYPP_RETHROW(excpt_r);
547  }
548 
549  // if the file does not exist remember it right away in our cache
550  if ( !result && requestMediaFile ) {
551  MIL << filename << " does not exist on medium, remembering in the cache" << std::endl;
552  mediaFileCache.insert_or_assign( mediaCacheKey, internal::SharedData::MediaFileCacheEntry( zypp::ManagedFile() ) );
553  }
554 
555  return result;
556  }
557 
558  void MediaNetwork::getDir( const Pathname & dirname, bool recurse_r ) const
559  {
560  filesystem::DirContent content;
561  getDirInfo( content, dirname, /*dots*/false );
562 
563  for ( filesystem::DirContent::const_iterator it = content.begin(); it != content.end(); ++it ) {
564  Pathname filename = dirname + it->name;
565  int res = 0;
566 
567  switch ( it->type ) {
568  case filesystem::FT_NOT_AVAIL: // old directory.yast contains no typeinfo at all
569  case filesystem::FT_FILE:
570  getFile( OnMediaLocation( filename ) );
571  break;
572  case filesystem::FT_DIR: // newer directory.yast contain at least directory info
573  if ( recurse_r ) {
574  getDir( filename, recurse_r );
575  } else {
576  res = assert_dir( localPath( filename ) );
577  if ( res ) {
578  WAR << "Ignore error (" << res << ") on creating local directory '" << localPath( filename ) << "'" << endl;
579  }
580  }
581  break;
582  default:
583  // don't provide devices, sockets, etc.
584  break;
585  }
586  }
587  }
588 
589  void MediaNetwork::getDirInfo( std::list<std::string> & retlist,
590  const Pathname & dirname, bool dots ) const
591  {
592  getDirectoryYast( retlist, dirname, dots );
593  }
594 
596  const Pathname & dirname, bool dots ) const
597  {
598  getDirectoryYast( retlist, dirname, dots );
599  }
600 
601  } // namespace media
602 } // namespace zypp
603 //
std::string getScheme() const
Returns the scheme name of the URL.
Definition: Url.cc:533
static const zypp::str::regex & mediaRegex()
Url getFileUrl(const Pathname &filename) const
concatenate the attach url and the filename to a complete download url
int assert_dir(const Pathname &path, unsigned mode)
Like &#39;mkdir -p&#39;.
Definition: PathInfo.cc:319
#define MIL
Definition: Logger.h:96
SignalProxy< void(Download &req, off_t dlnow)> sigAlive()
Definition: downloader.cc:315
const ByteCount & headerSize() const
The size of the header prepending the resource (e.g.
#define _(MSG)
Definition: Gettext.h:37
const Pathname & path() const
Return current Pathname.
Definition: PathInfo.h:246
#define ZYPP_THROW(EXCPT)
Drops a logline and throws the Exception.
Definition: Exception.h:428
Describes a resource file located on a medium.
Regular expression.
Definition: Regex.h:94
static ZConfig & instance()
Singleton ctor.
Definition: ZConfig.cc:832
bool getDoesFileExist(const Pathname &filename) const override
int _dnlPercent
Percent completed or 0 if _dnlTotal is unknown.
Definition: MediaNetwork.cc:57
virtual bool checkAttachPoint(const Pathname &apoint) const
Verify if the specified directory as attach point (root) as requires by the particular media handler ...
std::string asString() const
Definition: CheckSum.cc:176
void getDirInfo(std::list< std::string > &retlist, const Pathname &dirname, bool dots=true) const override
Call concrete handler to provide a content list of directory on media via retlist.
void save()
Saves any unsaved credentials added via addUserCred() or addGlobalCred() methods. ...
DownloadSpec & setTransferSettings(TransferSettings &&set)
SignalProxy< void(Download &req, NetworkAuthData &auth, const std::string &availAuth)> sigAuthRequired()
Definition: downloader.cc:330
void setAttachPoint(const Pathname &path, bool temp)
Set a new attach point.
std::optional< clock::time_point > _timeLast
Start last period(~1sec)
Definition: MediaNetwork.cc:51
static std::shared_ptr< SharedData > instance()
bool isUseableAttachPoint(const Pathname &path, bool mtab=true) const
Ask media manager, if the specified path is already used as attach point or if there are another atta...
Definition: Arch.h:351
static const Pathname & defaultLocation()
Definition: TmpPath.cc:157
AuthData_Ptr getCred(const Url &url)
Get credentials for the specified url.
double _drateLast
Download rate in last period.
Definition: MediaNetwork.cc:60
zypp::filesystem::TmpDir _mediaCacheDir
void disconnectFrom() override
Convenient building of std::string with boost::format.
Definition: String.h:252
SignalProxy< void(Download &req)> sigFinished()
Definition: downloader.cc:325
#define ZYPP_EXCPT_PTR(EXCPT)
Drops a logline and returns Exception as a std::exception_ptr.
Definition: Exception.h:432
constexpr std::string_view MEDIACACHE_REGEX("^\media\[1-9][0-9]*\media$")
static CheckSum md5FromString(const std::string &input_r)
Definition: CheckSum.h:103
Pathname localPath(const Pathname &pathname) const
Files provided will be available at &#39;localPath(filename)&#39;.
#define ZYPP_RETHROW(EXCPT)
Drops a logline and rethrows, updating the CodeLocation.
Definition: Exception.h:440
std::string asString() const
Returns a default string representation of the Url object.
Definition: Url.cc:497
auto findInCache(const std::string &mediaCacheKey)
Provide a new empty temporary directory and recursively delete it when no longer needed.
Definition: TmpPath.h:177
int unlink(const Pathname &path)
Like &#39;unlink&#39;.
Definition: PathInfo.cc:700
const Url _url
Url to handle.
Definition: MediaHandler.h:113
std::optional< clock::time_point > _timeStart
Start total stats.
Definition: MediaNetwork.cc:50
void setMediaSource(const MediaSourceRef &ref)
Set new media source reference.
const std::string & asString() const
String representation.
Definition: Pathname.h:91
Just inherits Exception to separate media exceptions.
const ByteCount & downloadSize() const
The size of the resource on the server.
void disconnect()
Use concrete handler to isconnect media.
Pathname dirname() const
Return all but the last component od this path.
Definition: Pathname.h:124
#define WAR
Definition: Logger.h:97
void updateStats(double dltotal=0.0, double dlnow=0.0)
Definition: MediaNetwork.cc:62
std::string asCompleteString() const
Returns a complete string representation of the Url object.
Definition: Url.cc:505
bool checkAttachPoint(const Pathname &apoint) const override
Verify if the specified directory as attach point (root) as requires by the particular media handler ...
std::shared_ptr<::internal::SharedData > _shared
Definition: MediaNetwork.h:77
std::list< DirEntry > DirContent
Returned by readdir.
Definition: PathInfo.h:518
int hardlinkCopy(const Pathname &oldpath, const Pathname &newpath)
Create newpath as hardlink or copy of oldpath.
Definition: PathInfo.cc:883
void attachTo(bool next=false) override
Call concrete handler to attach the media.
void getDirectoryYast(std::list< std::string > &retlist, const Pathname &dirname, bool dots=true) const
Retrieve and if available scan dirname/directory.yast.
bool isValid() const
Verifies the Url.
Definition: Url.cc:489
double _dnlLast
Bytes downloaded at period start.
Definition: MediaNetwork.cc:54
const zypp::Pathname & targetPath() const
Definition: downloadspec.cc:61
shared_ptr< CurlAuthData > CurlAuthData_Ptr
Definition: curlauthdata.h:102
const Pathname & filename() const
The path to the resource on the medium.
Common baseclass for MediaCurl and MediaNetwork.
Media source internally used by MediaManager and MediaHandler.
Definition: MediaSource.h:36
zypp::ByteCount expectedFileSize() const
void getFileCopy(const OnMediaLocation &file, const Pathname &targetFilename) const override
Call concrete handler to provide a file under a different place in the file system (usually not under...
#define ZYPP_CAUGHT(EXCPT)
Drops a logline telling the Exception was caught (in order to handle it).
Definition: Exception.h:436
zypp::media::CurlAuthData NetworkAuthData
Definition: authdata.h:24
shared_ptr< AuthData > AuthData_Ptr
Definition: authdata.h:79
int rmdir(const Pathname &path)
Like &#39;rmdir&#39;.
Definition: PathInfo.cc:366
const Pathname & deltafile() const
The existing deltafile that can be used to reduce download size ( zchunk or metalink ) ...
SignalProxy< void(Download &req)> sigStarted()
Definition: downloader.cc:305
zyppng::DownloaderRef _downloader
Pathname absolutename() const
Return this path, adding a leading &#39;/&#39; if relative.
Definition: Pathname.h:139
std::chrono::steady_clock::time_point _creationTime
Pathname attachPoint() const
Return the currently used attach point.
std::string getPathName(EEncoding eflag=zypp::url::E_DECODED) const
Returns the path name from the URL.
Definition: Url.cc:604
zyppng::EventDispatcherRef _dispatcher
SignalProxy< void(Download &req, off_t dltotal, off_t dlnow)> sigProgress()
Definition: downloader.cc:320
Wrapper class for ::stat/::lstat.
Definition: PathInfo.h:220
double _dnlNow
Bytes downloaded now.
Definition: MediaNetwork.cc:55
void getFile(const OnMediaLocation &file) const override
Call concrete handler to provide file below attach point.
void runRequest(const zyppng::DownloadSpec &spec, callback::SendReport< DownloadProgressReport > *report=nullptr) const
double _dnlTotal
Bytes to download or 0 if unknown.
Definition: MediaNetwork.cc:53
Pathname createAttachPoint() const
Try to create a default / temporary attach point.
void addCred(const AuthData &cred)
Add new credentials with user callbacks.
Easy-to use interface to the ZYPP dependency resolver.
Definition: CodePitfalls.doc:1
Curl HTTP authentication data.
Definition: curlauthdata.h:22
std::chrono::steady_clock clock
Definition: MediaNetwork.cc:48
void releaseFrom(const std::string &ejectDev) override
Call concrete handler to release the media.
void getDir(const Pathname &dirname, bool recurse_r) const override
Call concrete handler to provide directory content (not recursive!) below attach point.
double _drateTotal
Download rate so far.
Definition: MediaNetwork.cc:59
const Url & url() const
Definition: downloadspec.cc:50
bool userMayRWX() const
Definition: PathInfo.h:353
Url manipulation class.
Definition: Url.h:91
DownloadSpec & setCheckExistsOnly(bool set=true)
Definition: downloadspec.cc:83
static MediaConfig & instance()
Definition: mediaconfig.cc:43
#define DBG
Definition: Logger.h:95
const CheckSum & headerChecksum() const
The checksum of the header prepending the resource (e.g.
std::unordered_map< std::string, MediaFileCacheEntry > _mediaCacheEntries
MediaFileCacheEntry(zypp::ManagedFile &&file)
std::string getUsername(EEncoding eflag=zypp::url::E_DECODED) const
Returns the username from the URL authority.
Definition: Url.cc:572