libzypp 17.31.7
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
39using std::endl;
40
41namespace internal {
42
43
44 constexpr std::string_view MEDIACACHE_REGEX("^\\/media\\.[1-9][0-9]*\\/media$");
45
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;
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
155using namespace internal;
156using namespace zypp::base;
157
158namespace zypp {
159
160 namespace media {
161
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
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
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 ) {
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 }
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())
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 )
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 {
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
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 asString() const
Definition: CheckSum.cc:176
static CheckSum md5FromString(const std::string &input_r)
Definition: CheckSum.h:103
static MediaConfig & instance()
Definition: mediaconfig.cc:43
Describes a resource file located on a medium.
const ByteCount & downloadSize() const
The size of the resource on the server.
const Pathname & filename() const
The path to the resource on the medium.
const Pathname & deltafile() const
The existing deltafile that can be used to reduce download size ( zchunk or metalink )
const ByteCount & headerSize() const
The size of the header prepending the resource (e.g.
const CheckSum & headerChecksum() const
The checksum of the header prepending the resource (e.g.
Url manipulation class.
Definition: Url.h:92
std::string getScheme() const
Returns the scheme name of the URL.
Definition: Url.cc:533
std::string asCompleteString() const
Returns a complete string representation of the Url object.
Definition: Url.cc:505
std::string asString() const
Returns a default string representation of the Url object.
Definition: Url.cc:497
std::string getUsername(EEncoding eflag=zypp::url::E_DECODED) const
Returns the username from the URL authority.
Definition: Url.cc:572
std::string getPathName(EEncoding eflag=zypp::url::E_DECODED) const
Returns the path name from the URL.
Definition: Url.cc:604
bool isValid() const
Verifies the Url.
Definition: Url.cc:489
static ZConfig & instance()
Singleton ctor.
Definition: ZConfig.cc:832
Wrapper class for stat/lstat.
Definition: PathInfo.h:221
bool userMayRWX() const
Definition: PathInfo.h:353
const Pathname & path() const
Return current Pathname.
Definition: PathInfo.h:246
Pathname dirname() const
Return all but the last component od this path.
Definition: Pathname.h:124
const std::string & asString() const
String representation.
Definition: Pathname.h:91
Pathname absolutename() const
Return this path, adding a leading '/' if relative.
Definition: Pathname.h:139
Provide a new empty temporary directory and recursively delete it when no longer needed.
Definition: TmpPath.h:178
static const Pathname & defaultLocation()
Definition: TmpPath.cc:157
void save()
Saves any unsaved credentials added via addUserCred() or addGlobalCred() methods.
AuthData_Ptr getCred(const Url &url)
Get credentials for the specified url.
void addCred(const AuthData &cred)
Add new credentials with user callbacks.
Curl HTTP authentication data.
Definition: curlauthdata.h:22
Just inherits Exception to separate media exceptions.
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...
virtual bool checkAttachPoint(const Pathname &apoint) const
Verify if the specified directory as attach point (root) as requires by the particular media handler ...
void disconnect()
Use concrete handler to isconnect media.
Pathname createAttachPoint() const
Try to create a default / temporary attach point.
void setMediaSource(const MediaSourceRef &ref)
Set new media source reference.
Pathname localPath(const Pathname &pathname) const
Files provided will be available at 'localPath(filename)'.
const Url _url
Url to handle.
Definition: MediaHandler.h:113
void getDirectoryYast(std::list< std::string > &retlist, const Pathname &dirname, bool dots=true) const
Retrieve and if available scan dirname/directory.yast.
void setAttachPoint(const Pathname &path, bool temp)
Set a new attach point.
Pathname attachPoint() const
Return the currently used attach point.
Common baseclass for MediaCurl and MediaNetwork.
Url getFileUrl(const Pathname &filename) const
concatenate the attach url and the filename to a complete download url
bool checkAttachPoint(const Pathname &apoint) const override
Verify if the specified directory as attach point (root) as requires by the particular media handler ...
void disconnectFrom() override
void attachTo(bool next=false) override
Call concrete handler to attach the media.
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 getDir(const Pathname &dirname, bool recurse_r) const override
Call concrete handler to provide directory content (not recursive!) below attach point.
bool getDoesFileExist(const Pathname &filename) const override
void runRequest(const zyppng::DownloadSpec &spec, callback::SendReport< DownloadProgressReport > *report=nullptr) const
MediaNetwork(const Url &url_r, const Pathname &attach_point_hint_r)
void releaseFrom(const std::string &ejectDev) override
Call concrete handler to release the media.
void getFile(const OnMediaLocation &file) const override
Call concrete handler to provide file below attach point.
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...
std::shared_ptr<::internal::SharedData > _shared
Definition: MediaNetwork.h:77
Media source internally used by MediaManager and MediaHandler.
Definition: MediaSource.h:37
Regular expression.
Definition: Regex.h:95
DownloadSpec & setDeltaFile(const zypp::Pathname &file)
Definition: downloadspec.cc:94
DownloadSpec & setCheckExistsOnly(bool set=true)
Definition: downloadspec.cc:83
DownloadSpec & setHeaderChecksum(const zypp::CheckSum &sum)
DownloadSpec & setHeaderSize(const zypp::ByteCount &bc)
const zypp::Pathname & targetPath() const
Definition: downloadspec.cc:61
const Url & url() const
Definition: downloadspec.cc:50
DownloadSpec & setTransferSettings(TransferSettings &&set)
zypp::ByteCount expectedFileSize() const
constexpr std::string_view MEDIACACHE_REGEX("^\\/media\\.[1-9][0-9]*\\/media$")
Definition: Arch.h:352
int unlink(const Pathname &path)
Like 'unlink'.
Definition: PathInfo.cc:700
int hardlinkCopy(const Pathname &oldpath, const Pathname &newpath)
Create newpath as hardlink or copy of oldpath.
Definition: PathInfo.cc:883
std::list< DirEntry > DirContent
Returned by readdir.
Definition: PathInfo.h:518
shared_ptr< CurlAuthData > CurlAuthData_Ptr
Definition: curlauthdata.h:102
shared_ptr< AuthData > AuthData_Ptr
Definition: authdata.h:79
Easy-to use interface to the ZYPP dependency resolver.
Definition: CodePitfalls.doc:2
zypp::media::CurlAuthData NetworkAuthData
Definition: authdata.h:24
double _drateLast
Download rate in last period.
Definition: MediaNetwork.cc:60
double _drateTotal
Download rate so far.
Definition: MediaNetwork.cc:59
void updateStats(double dltotal=0.0, double dlnow=0.0)
Definition: MediaNetwork.cc:62
double _dnlTotal
Bytes to download or 0 if unknown.
Definition: MediaNetwork.cc:53
double _dnlLast
Bytes downloaded at period start.
Definition: MediaNetwork.cc:54
std::chrono::steady_clock clock
Definition: MediaNetwork.cc:48
double _dnlNow
Bytes downloaded now.
Definition: MediaNetwork.cc:55
int _dnlPercent
Percent completed or 0 if _dnlTotal is unknown.
Definition: MediaNetwork.cc:57
std::optional< clock::time_point > _timeStart
Start total stats.
Definition: MediaNetwork.cc:50
std::optional< clock::time_point > _timeLast
Start last period(~1sec)
Definition: MediaNetwork.cc:51
std::chrono::steady_clock::time_point _creationTime
MediaFileCacheEntry(zypp::ManagedFile &&file)
zypp::filesystem::TmpDir _mediaCacheDir
static std::shared_ptr< SharedData > instance()
static const zypp::str::regex & mediaRegex()
std::unordered_map< std::string, MediaFileCacheEntry > _mediaCacheEntries
zyppng::DownloaderRef _downloader
zyppng::EventDispatcherRef _dispatcher
auto findInCache(const std::string &mediaCacheKey)
Convenient building of std::string with boost::format.
Definition: String.h:253
#define ZYPP_RETHROW(EXCPT)
Drops a logline and rethrows, updating the CodeLocation.
Definition: Exception.h:440
#define ZYPP_CAUGHT(EXCPT)
Drops a logline telling the Exception was caught (in order to handle it).
Definition: Exception.h:436
#define ZYPP_EXCPT_PTR(EXCPT)
Drops a logline and returns Exception as a std::exception_ptr.
Definition: Exception.h:432
#define ZYPP_THROW(EXCPT)
Drops a logline and throws the Exception.
Definition: Exception.h:428
#define _(MSG)
Definition: Gettext.h:37
#define DBG
Definition: Logger.h:95
#define MIL
Definition: Logger.h:96
#define WAR
Definition: Logger.h:97