libzypp 17.31.6
MediaHandler.h
Go to the documentation of this file.
1
2/*---------------------------------------------------------------------\
3| ____ _ __ __ ___ |
4| |__ / \ / / . \ . \ |
5| / / \ V /| _/ _/ |
6| / /__ | | | | | | |
7| /_____||_| |_| |_| |
8| |
9\---------------------------------------------------------------------*/
13#ifndef ZYPP_MEDIA_MEDIAHANDLERL_H
14#define ZYPP_MEDIA_MEDIAHANDLERL_H
15
16#include <iosfwd>
17#include <string>
18#include <list>
19
20#include <zypp/Pathname.h>
21#include <zypp/PathInfo.h>
22#include <zypp/base/PtrTypes.h>
23
24#include <zypp/Url.h>
25
27#include <zypp-media/MediaException>
28#include <zypp/APIConfig.h>
29#include <zypp-core/OnMediaLocation>
30
31#undef ZYPP_BASE_LOGGER_LOGGROUP
32#define ZYPP_BASE_LOGGER_LOGGROUP "zypp::media"
33
34namespace zypp {
35 namespace media {
36
37 class MediaManager;
38
39
41//
42// CLASS NAME : MediaHandler
52 friend std::ostream & operator<<( std::ostream & str, const MediaHandler & obj );
53
54 public:
55 typedef shared_ptr<MediaHandler> Ptr;
56 typedef shared_ptr<const MediaHandler> constPtr;
57
58 static bool setAttachPrefix(const Pathname &attach_prefix);
59
60 static std::string getRealPath(const std::string &path);
61 static Pathname getRealPath(const Pathname &path);
62
63 private:
68
72 mutable
74
80
92
99
105
107 mutable time_t _attach_mtime;
108
109 protected:
113 const Url _url;
114
119
120 public:
121
128 bool dependsOnParent(MediaAccessId parentId,
129 bool exactIdMatch);
130 bool dependsOnParent();
131
137 void resetParentId();
138
142 Pathname attachPoint() const;
143
149 void setAttachPoint(const Pathname &path, bool temp);
150
155 void setAttachPoint(const AttachPointRef &ref);
156
161
167 void attachPointHint(const Pathname &path, bool temp);
168
183 Pathname createAttachPoint(const Pathname &attach_root) const;
184
189 void removeAttachPoint();
190
197 virtual bool checkAttachPoint(const Pathname &apoint) const;
198
207 static bool checkAttachPoint(const Pathname &apoint,
208 bool empty_dir,
209 bool writeable);
210
219 bool isUseableAttachPoint(const Pathname &path,
220 bool mtab=true) const;
221
226 std::string mediaSourceName() const
227 {
228 return _mediaSource ? _mediaSource->name : "";
229 }
230
235 void setMediaSource(const MediaSourceRef &ref);
236
242 findAttachedMedia(const MediaSourceRef &media) const;
243
256
261 bool isSharedMedia() const;
262
271 bool checkAttached(bool matchMountFs) const;
272
281 void forceRelaseAllMedia(bool matchMountFs);
282 void forceRelaseAllMedia(const MediaSourceRef &ref,
283 bool matchMountFs);
284
285 protected:
286
288 //
289 // Real action interface to be overloaded by concrete handler.
290 //
292
305 virtual void attachTo(bool next = false) = 0;
306
322 virtual void disconnectFrom() { return; }
323
336 virtual void releaseFrom( const std::string & ejectDev = "" ) = 0;
337
344 virtual void forceEject( const std::string & device ) {}
345
357 virtual void getFile( const OnMediaLocation &file ) const;
358
370 virtual void getFileCopy( const OnMediaLocation & file, const Pathname & targetFilename ) const;
371
372
388 virtual void getDir( const Pathname & dirname, bool recurse_r ) const = 0;
389
405 virtual void getDirInfo( std::list<std::string> & retlist,
406 const Pathname & dirname, bool dots = true ) const = 0;
407
419 virtual void getDirInfo( filesystem::DirContent & retlist,
420 const Pathname & dirname, bool dots = true ) const = 0;
421
430 virtual bool getDoesFileExist( const Pathname & filename ) const = 0;
431
432 protected:
433
442 void getDirectoryYast( std::list<std::string> & retlist,
443 const Pathname & dirname, bool dots = true ) const;
444
454 const Pathname & dirname, bool dots = true ) const;
455
456 public:
457
469 MediaHandler ( const Url& url_r,
470 const Pathname & attach_point_r,
471 const Pathname & urlpath_below_attachpoint_r,
472 const bool does_download_r );
473
478 virtual ~MediaHandler();
479
480 public:
481
482
484 //
485 // MediaAccess interface. Does common checks and logging.
486 // Invokes real action if necessary.
487 //
489
493 bool downloads() const { return _does_download; }
494
498 std::string protocol() const { return _url.getScheme(); }
499
503 Url url() const { return _url; }
504
515 void attach(bool next);
516
520 virtual bool isAttached() const { return _mediaSource != nullptr; }
521
530 Pathname localRoot() const;
531
537 Pathname localPath( const Pathname & pathname ) const;
538
552 void disconnect();
553
560 void release( const std::string & ejectDev = "" );
561
570 void provideFile( const OnMediaLocation &file ) const;
571
583 void provideFileCopy( const OnMediaLocation &srcFile, Pathname targetFilename ) const;
584
594 void provideDir( Pathname dirname ) const;
595
605 void provideDirTree( Pathname dirname ) const;
606
614 void releaseFile( const Pathname & filename ) const { return releasePath( filename ); }
615
623 void releaseDir( const Pathname & dirname ) const { return releasePath( dirname ); }
624
637 void releasePath( Pathname pathname ) const;
638
639 public:
640
654 void dirInfo( std::list<std::string> & retlist,
655 const Pathname & dirname, bool dots = true ) const;
656
669 void dirInfo( filesystem::DirContent & retlist,
670 const Pathname & dirname, bool dots = true ) const;
671
680 bool doesFileExist( const Pathname & filename ) const;
681
685 virtual bool hasMoreDevices();
686
695 virtual void
696 getDetectedDevices(std::vector<std::string> & devices,
697 unsigned int & index) const;
698
709 virtual void
710 precacheFiles ( const std::vector< OnMediaLocation > &files );
711};
712
714
715 } // namespace media
716} // namespace zypp
717
718
719#endif // ZYPP_MEDIA_MEDIAHANDLERL_H
Describes a resource file located on a medium.
Url manipulation class.
Definition: Url.h:92
std::string getScheme() const
Returns the scheme name of the URL.
Definition: Url.cc:533
Attach point of a media source.
Definition: MediaSource.h:106
Abstract base class for 'physical' MediaHandler like MediaCD, etc.
Definition: MediaHandler.h:51
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 void getFile(const OnMediaLocation &file) const
Call concrete handler to provide file below attach point.
virtual void attachTo(bool next=false)=0
Call concrete handler to attach the media.
Url url() const
Url used.
Definition: MediaHandler.h:503
virtual bool getDoesFileExist(const Pathname &filename) const =0
check if a file exists
virtual void getDetectedDevices(std::vector< std::string > &devices, unsigned int &index) const
Fill in a vector of detected ejectable devices and the index of the currently attached device within ...
void provideDirTree(Pathname dirname) const
Use concrete handler to provide directory tree denoted by path below 'localRoot' (recursive!...
MediaHandler(const Url &url_r, const Pathname &attach_point_r, const Pathname &urlpath_below_attachpoint_r, const bool does_download_r)
If the concrete media handler provides a nonempty attach_point, it must be an existing directory.
Definition: MediaHandler.cc:54
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.
MediaSourceRef _mediaSource
The attached media source description reference.
Definition: MediaHandler.h:73
shared_ptr< const MediaHandler > constPtr
Definition: MediaHandler.h:56
void attach(bool next)
Use concrete handler to attach the media.
void resetParentId()
Called in case, where the media manager takes over the destruction of the parent id (e....
time_t _attach_mtime
timestamp of the the last attach verification
Definition: MediaHandler.h:107
virtual void precacheFiles(const std::vector< OnMediaLocation > &files)
Tries to fetch the given files and precaches them.
virtual bool isAttached() const
True if media is attached.
Definition: MediaHandler.h:520
virtual bool hasMoreDevices()
Check if the media has one more device available for attach(true).
AttachPoint _attachPointHint
The user provided attach preferred point.
Definition: MediaHandler.h:91
virtual void disconnectFrom()
Call concrete handler to disconnect media.
Definition: MediaHandler.h:322
static std::string getRealPath(const std::string &path)
bool downloads() const
Hint if files are downloaded or not.
Definition: MediaHandler.h:493
void dirInfo(std::list< std::string > &retlist, const Pathname &dirname, bool dots=true) const
Return content of directory on media via retlist.
Pathname createAttachPoint() const
Try to create a default / temporary attach point.
AttachPointRef _attachPoint
This is where the media will be actually attached ("mounted").
Definition: MediaHandler.h:79
AttachPoint attachPointHint() const
Get the actual attach point hint.
void releaseDir(const Pathname &dirname) const
Remove directory tree below localRoot IFF handler downloads files to the local filesystem.
Definition: MediaHandler.h:623
bool doesFileExist(const Pathname &filename) const
check if a file exists
void releasePath(Pathname pathname) const
Remove pathname below localRoot IFF handler downloads files to the local filesystem.
static bool setAttachPrefix(const Pathname &attach_prefix)
std::string mediaSourceName() const
Get the media source name or an empty string.
Definition: MediaHandler.h:226
virtual void getFileCopy(const OnMediaLocation &file, const Pathname &targetFilename) const
Call concrete handler to provide a file under a different place in the file system (usually not under...
void setMediaSource(const MediaSourceRef &ref)
Set new media source reference.
Pathname localPath(const Pathname &pathname) const
Files provided will be available at 'localPath(filename)'.
static Pathname _attachPrefix
User defined default attach point prefix.
Definition: MediaHandler.h:67
std::string protocol() const
Protocol hint for MediaAccess.
Definition: MediaHandler.h:498
friend std::ostream & operator<<(std::ostream &str, const MediaHandler &obj)
void forceRelaseAllMedia(bool matchMountFs)
Call to this function will try to release all media matching the currenlty attached media source,...
const Url _url
Url to handle.
Definition: MediaHandler.h:113
void release(const std::string &ejectDev="")
Use concrete handler to release the media.
bool checkAttached(bool matchMountFs) const
Check actual mediaSource attachment against the current mount table of the system.
void removeAttachPoint()
Remove unused attach point.
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.
void releaseFile(const Pathname &filename) const
Remove filename below localRoot IFF handler downloads files to the local filesystem.
Definition: MediaHandler.h:614
Pathname localRoot() const
Return the local directory that corresponds to medias url, no matter if media isAttached or not.
void provideDir(Pathname dirname) const
Use concrete handler to provide directory denoted by path below 'localRoot' (not recursive!...
shared_ptr< MediaHandler > Ptr
Definition: MediaHandler.h:55
virtual ~MediaHandler()
Contolling MediaAccess takes care, that attached media is released prior to deleting this.
void provideFileCopy(const OnMediaLocation &srcFile, Pathname targetFilename) const
Call concrete handler to provide a copy of a file under a different place in the file system (usually...
virtual void getDir(const Pathname &dirname, bool recurse_r) const =0
Call concrete handler to provide directory content (not recursive!) below attach point.
Pathname _relativeRoot
The relative root directory of the data on the media.
Definition: MediaHandler.h:98
AttachedMedia findAttachedMedia(const MediaSourceRef &media) const
Ask the media manager if specified media source is already attached.
bool isSharedMedia() const
Returns a hint if the media is shared or not.
virtual void releaseFrom(const std::string &ejectDev="")=0
Call concrete handler to release the media.
void provideFile(const OnMediaLocation &file) const
Use concrete handler to provide file denoted by path below 'localRoot'.
AttachedMedia attachedMedia() const
Returns the attached media.
virtual void forceEject(const std::string &device)
Call concrete handler to physically eject the media (i.e.
Definition: MediaHandler.h:344
bool _does_download
True if concrete handler downloads files to the local filesystem.
Definition: MediaHandler.h:104
virtual void getDirInfo(std::list< std::string > &retlist, const Pathname &dirname, bool dots=true) const =0
Call concrete handler to provide a content list of directory on media via retlist.
MediaAccessId _parentId
Access Id of media handler we depend on.
Definition: MediaHandler.h:118
String related utilities and Regular expression matching.
std::list< DirEntry > DirContent
Returned by readdir.
Definition: PathInfo.h:518
unsigned int MediaAccessId
Media manager access Id type.
Definition: MediaSource.h:29
Easy-to use interface to the ZYPP dependency resolver.
Definition: CodePitfalls.doc:2
A simple structure containing references to a media source and its attach point.
Definition: MediaSource.h:134