libzypp  17.14.0
MediaManager.cc
Go to the documentation of this file.
1 /*---------------------------------------------------------------------\
2 | ____ _ __ __ ___ |
3 | |__ / \ / / . \ . \ |
4 | / / \ V /| _/ _/ |
5 | / /__ | | | | | | |
6 | /_____||_| |_| |_| |
7 | |
8 \---------------------------------------------------------------------*/
12 #include <map>
13 #include <list>
14 #include <iostream>
15 #include <typeinfo>
16 
20 #include "zypp/media/Mount.h"
21 
22 #include "zypp/base/String.h"
23 #include "zypp/base/Logger.h"
24 #include "zypp/Pathname.h"
25 #include "zypp/PathInfo.h"
26 
28 namespace zypp
29 {
30 
32  namespace media
33  {
34 
36  namespace // anonymous
37  {
38 
39  // -------------------------------------------------------------
40  struct ManagedMedia
41  {
42  ~ManagedMedia()
43  {}
44 
45  ManagedMedia()
46  : desired (false)
47  {}
48 
49  ManagedMedia(const ManagedMedia &m)
50  : desired (m.desired)
51  , handler (m.handler)
52  , verifier(m.verifier)
53  {}
54 
55  ManagedMedia(const MediaAccessRef &h, const MediaVerifierRef &v)
56  : desired (false)
57  , handler (h)
58  , verifier(v)
59  {}
60 
61  inline void
62  checkAttached(MediaAccessId id)
63  {
64  if( !handler->isAttached())
65  {
66  DBG << "checkAttached(" << id << ") not attached" << std::endl;
67  desired = false;
68  ZYPP_THROW(MediaNotAttachedException(
69  handler->url()
70  ));
71  }
72  }
73 
74  inline void checkDesired( MediaAccessId id )
75  {
76  checkAttached( id );
77 
78  if ( !desired )
79  {
80  try {
81  desired = verifier->isDesiredMedia(handler);
82  } catch ( const zypp::Exception &e ) {
83  ZYPP_CAUGHT( e );
84 
85  media::MediaNotDesiredException newEx ( handler->url() );
86  newEx.remember( e );
87  ZYPP_THROW( newEx );
88  }
89 
90  if( !desired )
91  {
92  DBG << "checkDesired(" << id << "): not desired (report by " << verifier->info() << ")" << std::endl;
93  ZYPP_THROW( MediaNotDesiredException( handler->url() ) );
94  }
95 
96  DBG << "checkDesired(" << id << "): desired (report by " << verifier->info() << ")" << std::endl;
97  } else {
98  DBG << "checkDesired(" << id << "): desired (cached)" << std::endl;
99  }
100  }
101 
102  bool desired;
105  };
106 
107 
108  // -------------------------------------------------------------
109  typedef std::map<MediaAccessId, ManagedMedia> ManagedMediaMap;
110 
112  } // anonymous
114 
115 
117  std::string
119  {
120  return std::string(typeid((*this)).name());
121  }
122 
123 
125  std::string
127  {
128  return std::string("zypp::media::NoVerifier");
129  }
130 
131 
134  {
135  private:
136  friend class MediaManager;
137 
139  ManagedMediaMap mediaMap;
140 
142  : last_accessid(0)
143  {}
144 
145  public:
147  {
148  try
149  {
150  // remove depending (iso) handlers first
151  ManagedMediaMap::iterator it;
152  bool found;
153  do
154  {
155  found = false;
156  for(it = mediaMap.begin(); it != mediaMap.end(); )
157  {
158  if( it->second.handler->dependsOnParent())
159  {
160  found = true;
161  // let it forget its parent, we will
162  // destroy it later (in clear())...
163  it->second.handler->resetParentId();
164  mediaMap.erase( it++ ); // postfix! Incrementing before erase
165  } else {
166  ++it;
167  }
168  }
169  } while(found);
170 
171  // remove all other handlers
172  mediaMap.clear();
173  }
174  catch( ... )
175  {}
176  }
177 
178  inline MediaAccessId
180  {
181  return ++last_accessid;
182  }
183 
184  inline bool
185  hasId(MediaAccessId accessId) const
186  {
187  return mediaMap.find(accessId) != mediaMap.end();
188  }
189 
190  inline ManagedMedia &
192  {
193  ManagedMediaMap::iterator it( mediaMap.find(accessId));
194  if( it == mediaMap.end())
195  {
197  "Invalid media access id " + str::numstring(accessId)
198  ));
199  }
200  return it->second;
201  }
202 
203  static inline time_t
205  {
206  time_t mtime = zypp::PathInfo("/etc/mtab").mtime();
207  if( mtime <= 0)
208  {
209  WAR << "Failed to retrieve modification time of '/etc/mtab'"
210  << std::endl;
211  }
212  return mtime;
213  }
214 
215  static inline MountEntries
217  {
218  return Mount::getEntries();
219  }
220 
221  };
222 
223 
225  // STATIC
227 
228 
231  {
232  if( !m_impl)
233  {
234  m_impl.reset( new MediaManager_Impl());
235  }
236  }
237 
238  // ---------------------------------------------------------------
240  {
241  }
242 
243  // ---------------------------------------------------------------
245  MediaManager::open(const Url &url, const Pathname &preferred_attach_point)
246  {
247  // create new access handler for it
250  ManagedMedia tmp( handler, verifier);
251 
252  tmp.handler->open(url, preferred_attach_point);
253 
254  MediaAccessId nextId = m_impl->nextAccessId();
255 
256  m_impl->mediaMap[nextId] = tmp;
257 
258  DBG << "Opened new media access using id " << nextId
259  << " to " << url.asString() << std::endl;
260  return nextId;
261  }
262 
263  // ---------------------------------------------------------------
264  void
266  {
267  //
268  // The MediaISO handler internally requests an accessId
269  // of a "parent" handler providing the iso file.
270  // The parent handler accessId is private to MediaISO,
271  // but the attached media source may be shared reference.
272  // This means, that if the accessId exactly matches the
273  // parent handler id, close was used on uninitialized
274  // accessId variable (or the accessId was guessed) and
275  // the close request to this id will be rejected here.
276  //
277  ManagedMediaMap::iterator m(m_impl->mediaMap.begin());
278  for( ; m != m_impl->mediaMap.end(); ++m)
279  {
280  if( m->second.handler->dependsOnParent(accessId, true))
281  {
283  m->second.handler->url().asString()
284  ));
285  }
286  }
287 
288  DBG << "Close to access handler using id "
289  << accessId << " requested" << std::endl;
290 
291  ManagedMedia &ref( m_impl->findMM(accessId));
292  ref.handler->close();
293 
294  m_impl->mediaMap.erase(accessId);
295  }
296 
297  // ---------------------------------------------------------------
298  bool
300  {
301  ManagedMediaMap::iterator it( m_impl->mediaMap.find(accessId));
302  return it != m_impl->mediaMap.end() &&
303  it->second.handler->isOpen();
304  }
305 
306  // ---------------------------------------------------------------
307  std::string
309  {
310  ManagedMedia &ref( m_impl->findMM(accessId));
311 
312  return ref.handler->protocol();
313  }
314 
315  // ---------------------------------------------------------------
316  bool
318  {
319  ManagedMedia &ref( m_impl->findMM(accessId));
320 
321  return ref.handler->downloads();
322  }
323 
324  // ---------------------------------------------------------------
325  Url
327  {
328  ManagedMedia &ref( m_impl->findMM(accessId));
329 
330  return ref.handler->url();
331  }
332 
333  // ---------------------------------------------------------------
334  void
336  const MediaVerifierRef &verifier)
337  {
338  if( !verifier)
339  ZYPP_THROW(MediaException("Invalid verifier reference"));
340 
341  ManagedMedia &ref( m_impl->findMM(accessId));
342 
343  ref.desired = false;
344  MediaVerifierRef(verifier).swap(ref.verifier);
345 
346  DBG << "MediaVerifier change: id=" << accessId << ", verifier="
347  << verifier->info() << std::endl;
348  }
349 
350  // ---------------------------------------------------------------
351  void
353  {
354  ManagedMedia &ref( m_impl->findMM(accessId));
355 
357  ref.desired = false;
358  ref.verifier.swap(verifier);
359 
360  DBG << "MediaVerifier change: id=" << accessId << ", verifier="
361  << verifier->info() << std::endl;
362  }
363 
364  // ---------------------------------------------------------------
365  bool
367  {
368  return MediaHandler::setAttachPrefix(attach_prefix);
369  }
370 
371  // ---------------------------------------------------------------
373  {
374  ManagedMedia &ref( m_impl->findMM(accessId));
375 
376  DBG << "attach(id=" << accessId << ")" << std::endl;
377 
378  // try first mountable/mounted device
379  ref.handler->attach(false);
380  try
381  {
382  ref.checkDesired(accessId);
383  return;
384  }
385  catch (const MediaException & ex)
386  {
387  ZYPP_CAUGHT(ex);
388 
389  if (!ref.handler->hasMoreDevices())
390  ZYPP_RETHROW(ex);
391 
392  if (ref.handler->isAttached())
393  ref.handler->release();
394  }
395 
396  MIL << "checkDesired(" << accessId << ") of first device failed,"
397  " going to try others with attach(true)" << std::endl;
398 
399  while (ref.handler->hasMoreDevices())
400  {
401  try
402  {
403  // try to attach next device
404  ref.handler->attach(true);
405  ref.checkDesired(accessId);
406  return;
407  }
408  catch (const MediaNotDesiredException & ex)
409  {
410  ZYPP_CAUGHT(ex);
411 
412  if (!ref.handler->hasMoreDevices())
413  {
414  MIL << "No desired media found after trying all detected devices." << std::endl;
415  ZYPP_RETHROW(ex);
416  }
417 
418  AttachedMedia media(ref.handler->attachedMedia());
419  DBG << "Skipping " << media.mediaSource->asString() << ": not desired media." << std::endl;
420 
421  ref.handler->release();
422  }
423  catch (const MediaException & ex)
424  {
425  ZYPP_CAUGHT(ex);
426 
427  if (!ref.handler->hasMoreDevices())
428  ZYPP_RETHROW(ex);
429 
430  AttachedMedia media(ref.handler->attachedMedia());
431  DBG << "Skipping " << media.mediaSource->asString() << " because of exception thrown by attach(true)" << std::endl;
432 
433  if (ref.handler->isAttached()) ref.handler->release();
434  }
435  }
436  }
437 
438  // ---------------------------------------------------------------
439  void
440  MediaManager::release(MediaAccessId accessId, const std::string & ejectDev)
441  {
442  ManagedMedia &ref( m_impl->findMM(accessId));
443 
444  DBG << "release(id=" << accessId;
445  if (!ejectDev.empty())
446  DBG << ", " << ejectDev;
447  DBG << ")" << std::endl;
448 
449  if(!ejectDev.empty())
450  {
451  //
452  // release MediaISO handlers, that are using the one
453  // specified with accessId, because it provides the
454  // iso file and it will disappear now (forced release
455  // with eject).
456  //
457  ManagedMediaMap::iterator m(m_impl->mediaMap.begin());
458  for( ; m != m_impl->mediaMap.end(); ++m)
459  {
460  if( m->second.handler->dependsOnParent(accessId, false))
461  {
462  try
463  {
464  DBG << "Forcing release of handler depending on access id "
465  << accessId << std::endl;
466  m->second.desired = false;
467  m->second.handler->release();
468  }
469  catch(const MediaException &e)
470  {
471  ZYPP_CAUGHT(e);
472  }
473  }
474  }
475  }
476  ref.desired = false;
477  ref.handler->release(ejectDev);
478  }
479 
480  // ---------------------------------------------------------------
481  void
483  {
484  MIL << "Releasing all attached media" << std::endl;
485 
486  ManagedMediaMap::iterator m(m_impl->mediaMap.begin());
487  for( ; m != m_impl->mediaMap.end(); ++m)
488  {
489  if( m->second.handler->dependsOnParent())
490  continue;
491 
492  try
493  {
494  if(m->second.handler->isAttached())
495  {
496  DBG << "Releasing media id " << m->first << std::endl;
497  m->second.desired = false;
498  m->second.handler->release();
499  }
500  else
501  {
502  DBG << "Media id " << m->first << " not attached " << std::endl;
503  }
504  }
505  catch(const MediaException & e)
506  {
507  ZYPP_CAUGHT(e);
508  ERR << "Failed to release media id " << m->first << std::endl;
509  }
510  }
511 
512  MIL << "Exit" << std::endl;
513  }
514 
515  // ---------------------------------------------------------------
516  void
518  {
519  ManagedMedia &ref( m_impl->findMM(accessId));
520 
521  ref.handler->disconnect();
522  }
523 
524  // ---------------------------------------------------------------
525  bool
527  {
528  ManagedMedia &ref( m_impl->findMM(accessId));
529 
530  return ref.handler->isAttached();
531  }
532 
533  // ---------------------------------------------------------------
535  {
536  ManagedMedia &ref( m_impl->findMM(accessId));
537 
538  return ref.handler->isSharedMedia();
539  }
540 
541  // ---------------------------------------------------------------
542  bool
544  {
545  ManagedMedia &ref( m_impl->findMM(accessId));
546 
547  if( !ref.handler->isAttached())
548  {
549  ref.desired = false;
550  }
551  else
552  {
553  try {
554  ref.desired = ref.verifier->isDesiredMedia(ref.handler);
555  }
556  catch(const zypp::Exception &e) {
557  ZYPP_CAUGHT(e);
558  ref.desired = false;
559  }
560  }
561  DBG << "isDesiredMedia(" << accessId << "): "
562  << (ref.desired ? "" : "not ")
563  << "desired (report by "
564  << ref.verifier->info() << ")" << std::endl;
565  return ref.desired;
566  }
567 
568  // ---------------------------------------------------------------
569  bool
571  const MediaVerifierRef &verifier) const
572  {
574  if( !v)
575  ZYPP_THROW(MediaException("Invalid verifier reference"));
576 
577  ManagedMedia &ref( m_impl->findMM(accessId));
578 
579  bool desired = false;
580  if( ref.handler->isAttached())
581  {
582  try {
583  desired = v->isDesiredMedia(ref.handler);
584  }
585  catch(const zypp::Exception &e) {
586  ZYPP_CAUGHT(e);
587  desired = false;
588  }
589  }
590  DBG << "isDesiredMedia(" << accessId << "): "
591  << (desired ? "" : "not ")
592  << "desired (report by "
593  << v->info() << ")" << std::endl;
594  return desired;
595  }
596 
597  // ---------------------------------------------------------------
598  bool
600  {
601  return url(accessId).getScheme() == "cd" || url(accessId).getScheme() == "dvd";
602  }
603 
604  // ---------------------------------------------------------------
605  Pathname
607  {
608  ManagedMedia &ref( m_impl->findMM(accessId));
609 
610  Pathname path;
611  path = ref.handler->localRoot();
612  return path;
613  }
614 
615  // ---------------------------------------------------------------
616  Pathname
618  const Pathname & pathname) const
619  {
620  ManagedMedia &ref( m_impl->findMM(accessId));
621 
622  Pathname path;
623  path = ref.handler->localPath(pathname);
624  return path;
625  }
626 
627  void
629  const Pathname &filename,
630  const ByteCount &expectedFileSize ) const
631  {
632  ManagedMedia &ref( m_impl->findMM(accessId));
633 
634  ref.checkDesired(accessId);
635 
636  ref.handler->provideFile(filename, expectedFileSize);
637  }
638 
639  // ---------------------------------------------------------------
640  void
642  const Pathname &filename ) const
643  {
644  provideFile( accessId, filename, 0);
645  }
646 
647  // ---------------------------------------------------------------
648  void
650  const Pathname &filename ) const
651  {
652  ManagedMedia &ref( m_impl->findMM(accessId));
653 
654  ref.checkDesired(accessId);
655 
656  ref.handler->setDeltafile(filename);
657  }
658 
659  // ---------------------------------------------------------------
660  void
662  const Pathname &dirname) const
663  {
664  ManagedMedia &ref( m_impl->findMM(accessId));
665 
666  ref.checkDesired(accessId);
667 
668  ref.handler->provideDir(dirname);
669  }
670 
671  // ---------------------------------------------------------------
672  void
674  const Pathname &dirname) const
675  {
676  ManagedMedia &ref( m_impl->findMM(accessId));
677 
678  ref.checkDesired(accessId);
679 
680  ref.handler->provideDirTree(dirname);
681  }
682 
683  // ---------------------------------------------------------------
684  void
686  const Pathname &filename) const
687  {
688  ManagedMedia &ref( m_impl->findMM(accessId));
689 
690  ref.checkAttached(accessId);
691 
692  ref.handler->releaseFile(filename);
693  }
694 
695  // ---------------------------------------------------------------
696  void
698  const Pathname &dirname) const
699  {
700  ManagedMedia &ref( m_impl->findMM(accessId));
701 
702  ref.checkAttached(accessId);
703 
704  ref.handler->releaseDir(dirname);
705  }
706 
707 
708  // ---------------------------------------------------------------
709  void
711  const Pathname &pathname) const
712  {
713  ManagedMedia &ref( m_impl->findMM(accessId));
714 
715  ref.checkAttached(accessId);
716 
717  ref.handler->releasePath(pathname);
718  }
719 
720  // ---------------------------------------------------------------
721  void
723  std::list<std::string> &retlist,
724  const Pathname &dirname,
725  bool dots) const
726  {
727  ManagedMedia &ref( m_impl->findMM(accessId));
728 
729  // FIXME: ref.checkDesired(accessId); ???
730  ref.checkAttached(accessId);
731 
732  ref.handler->dirInfo(retlist, dirname, dots);
733  }
734 
735  // ---------------------------------------------------------------
736  void
738  filesystem::DirContent &retlist,
739  const Pathname &dirname,
740  bool dots) const
741  {
742  ManagedMedia &ref( m_impl->findMM(accessId));
743 
744  // FIXME: ref.checkDesired(accessId); ???
745  ref.checkAttached(accessId);
746 
747  ref.handler->dirInfo(retlist, dirname, dots);
748  }
749 
750  // ---------------------------------------------------------------
751  bool
752  MediaManager::doesFileExist(MediaAccessId accessId, const Pathname & filename ) const
753  {
754  ManagedMedia &ref( m_impl->findMM(accessId));
755 
756  // FIXME: ref.checkDesired(accessId); ???
757  ref.checkAttached(accessId);
758 
759  return ref.handler->doesFileExist(filename);
760  }
761 
762  // ---------------------------------------------------------------
763  void
765  std::vector<std::string> & devices,
766  unsigned int & index) const
767  {
768  ManagedMedia &ref( m_impl->findMM(accessId));
769  return ref.handler->getDetectedDevices(devices, index);
770  }
771 
772  // ---------------------------------------------------------------
773  // STATIC
774  time_t
776  {
778  }
779 
780  // ---------------------------------------------------------------
781  // STATIC
782  MountEntries
784  {
786  }
787 
788  // ---------------------------------------------------------------
789  bool
791  bool mtab) const
792  {
793  if( path.empty() || path == "/" || !PathInfo(path).isDir())
794  return false;
795 
796  //
797  // check against our current attach points
798  //
799  ManagedMediaMap::const_iterator m(m_impl->mediaMap.begin());
800  for( ; m != m_impl->mediaMap.end(); ++m)
801  {
802  AttachedMedia ret = m->second.handler->attachedMedia();
803  if( ret.mediaSource && ret.attachPoint)
804  {
805  std::string mnt(ret.attachPoint->path.asString());
806  std::string our(path.asString());
807 
808  if( our == mnt)
809  {
810  // already used as attach point
811  return false;
812  }
813  else
814  if( mnt.size() > our.size() &&
815  mnt.at(our.size()) == '/' &&
816  !mnt.compare(0, our.size(), our))
817  {
818  // mountpoint is bellow of path
819  // (would hide the content)
820  return false;
821  }
822  }
823  }
824 
825  if( !mtab)
826  return true;
827 
828  //
829  // check against system mount entries
830  //
831  MountEntries entries( m_impl->getMountEntries());
832  MountEntries::const_iterator e;
833  for( e = entries.begin(); e != entries.end(); ++e)
834  {
835  std::string mnt(Pathname(e->dir).asString());
836  std::string our(path.asString());
837 
838  if( our == mnt)
839  {
840  // already used as mountpoint
841  return false;
842  }
843  else
844  if( mnt.size() > our.size() &&
845  mnt.at(our.size()) == '/' &&
846  !mnt.compare(0, our.size(), our))
847  {
848  // mountpoint is bellow of path
849  // (would hide the content)
850  return false;
851  }
852  }
853 
854  return true;
855  }
856 
857  // ---------------------------------------------------------------
860  {
861  ManagedMedia &ref( m_impl->findMM(accessId));
862 
863  return ref.handler->attachedMedia();
864  }
865 
866  // ---------------------------------------------------------------
869  {
870  if( !media || media->type.empty())
871  return AttachedMedia();
872 
873  ManagedMediaMap::const_iterator m(m_impl->mediaMap.begin());
874  for( ; m != m_impl->mediaMap.end(); ++m)
875  {
876  if( !m->second.handler->isAttached())
877  continue;
878 
879  AttachedMedia ret = m->second.handler->attachedMedia();
880  if( ret.mediaSource && ret.mediaSource->equals( *media))
881  return ret;
882  }
883  return AttachedMedia();
884  }
885 
886  // ---------------------------------------------------------------
887  void
889  {
890  if( !media || media->type.empty())
891  return;
892 
893  ManagedMediaMap::iterator m(m_impl->mediaMap.begin());
894  for( ; m != m_impl->mediaMap.end(); ++m)
895  {
896  if( !m->second.handler->isAttached())
897  continue;
898 
899  AttachedMedia ret = m->second.handler->attachedMedia();
900  if( ret.mediaSource && ret.mediaSource->equals( *media))
901  {
902  m->second.handler->release();
903  m->second.desired = false;
904  }
905  }
906  }
907 
909  } // namespace media
911 
913 } // namespace zypp
915 /*
916 ** vim: set ts=2 sts=2 sw=2 ai et:
917 */
std::string getScheme() const
Returns the scheme name of the URL.
Definition: Url.cc:528
Dummy default media verifier, which is always happy.
Definition: MediaManager.h:88
AttachedMedia findAttachedMedia(const MediaSourceRef &media) const
#define MIL
Definition: Logger.h:79
static time_t getMountTableMTime()
void releasePath(MediaAccessId accessId, const Pathname &pathname) const
FIXME: see MediaAccess class.
void provideDirTree(MediaAccessId accessId, const Pathname &dirname) const
FIXME: see MediaAccess class.
void setDeltafile(MediaAccessId accessId, const Pathname &filename) const
#define ZYPP_THROW(EXCPT)
Drops a logline and throws the Exception.
Definition: Exception.h:392
bool doesFileExist(MediaAccessId accessId, const Pathname &filename) const
FIXME: see MediaAccess class.
Handle access to a medium.
Definition: MediaAccess.h:50
zypp::RW_pointer< MediaVerifierBase > MediaVerifierRef
A shared reference to the MediaVerifier implementation.
Definition: MediaManager.h:124
Store and operate with byte count.
Definition: ByteCount.h:30
void dirInfo(MediaAccessId accessId, std::list< std::string > &retlist, const Pathname &dirname, bool dots=true) const
FIXME: see MediaAccess class.
time_t mtime() const
Definition: PathInfo.h:376
Url url
Definition: MediaCurl.cc:180
bool isOpen(MediaAccessId accessId) const
Query if the media access is open / exists.
void provideFile(MediaAccessId accessId, const Pathname &filename, const ByteCount &expectedFileSize) const
Provide provide file denoted by relative path below of the 'attach point' of the specified media and ...
static MountEntries getMountEntries()
#define ERR
Definition: Logger.h:81
unsigned int MediaAccessId
Media manager access Id type.
Definition: MediaSource.h:29
bool isChangeable(MediaAccessId accessId)
Simple check, based on media's URL scheme, telling whether the it is possible to physically change th...
bool setAttachPrefix(const Pathname &attach_prefix)
Set or resets the directory name, where the media manager handlers create their temporary attach poin...
void disconnect(MediaAccessId accessId)
Disconnect a remote media.
static zypp::RW_pointer< MediaManager_Impl > m_impl
Static reference to the implementation (singleton).
Definition: MediaManager.h:916
virtual std::string info() const
Returns a string with some info about the verifier.
Pathname localPath(MediaAccessId accessId, const Pathname &pathname) const
Shortcut for 'localRoot() + pathname', but returns an empty pathname if media is not attached.
~MediaManager()
Destroys MediaManager envelope instance.
void release(MediaAccessId accessId, const std::string &ejectDev="")
Release the attached media and optionally eject.
bool empty() const
Test for an empty path.
Definition: Pathname.h:113
#define ZYPP_RETHROW(EXCPT)
Drops a logline and rethrows, updating the CodeLocation.
Definition: Exception.h:400
AttachPointRef attachPoint
Definition: MediaSource.h:145
std::string asString() const
Returns a default string representation of the Url object.
Definition: Url.cc:492
MediaAccessRef handler
MediaSourceRef mediaSource
Definition: MediaSource.h:144
A simple structure containing references to a media source and its attach point.
Definition: MediaSource.h:133
bool desired
const std::string & asString() const
String representation.
Definition: Pathname.h:90
Just inherits Exception to separate media exceptions.
ManagedMedia & findMM(MediaAccessId accessId)
static bool setAttachPrefix(const Pathname &attach_prefix)
#define WAR
Definition: Logger.h:80
bool hasId(MediaAccessId accessId) const
std::list< DirEntry > DirContent
Returned by readdir.
Definition: PathInfo.h:547
void addVerifier(MediaAccessId accessId, const MediaVerifierRef &verifier)
Add verifier implementation for the specified media id.
AttachedMedia getAttachedMedia(MediaAccessId &accessId) const
std::string numstring(char n, int w=0)
Definition: String.h:288
void provideDir(MediaAccessId accessId, const Pathname &dirname) const
FIXME: see MediaAccess class.
void forceReleaseShared(const MediaSourceRef &media)
void attach(MediaAccessId accessId)
Attach the media using the concrete handler (checks all devices).
MediaManager()
Creates a MediaManager envelope instance.
void releaseDir(MediaAccessId accessId, const Pathname &dirname) const
FIXME: see MediaAccess class.
#define ZYPP_CAUGHT(EXCPT)
Drops a logline telling the Exception was caught (in order to handle it).
Definition: Exception.h:396
Url url(MediaAccessId accessId) const
Returns the Media Access Url of the media access id.
Manages access to the 'physical' media, e.g CDROM drives, Disk volumes, directory trees,...
Definition: MediaManager.h:470
bool isSharedMedia(MediaAccessId accessId) const
Returns information if media is on a shared physical device or not.
Base class for Exception.
Definition: Exception.h:145
static MountEntries getEntries(const std::string &mtab="")
Return mount entries from /etc/mtab or /etc/fstab file.
Definition: Mount.cc:275
bool downloads(MediaAccessId accessId) const
Hint if files are downloaded or not.
MediaVerifierRef verifier
virtual std::string info() const
Returns the "zypp::media::NoVerifier" string.
Wrapper for const correct access via Smart pointer types.
Definition: PtrTypes.h:285
Wrapper class for ::stat/::lstat.
Definition: PathInfo.h:220
bool isAttached(MediaAccessId accessId) const
Check if media is attached or not.
void releaseAll()
Release all attached media.
bool isDesiredMedia(MediaAccessId accessId) const
Ask the registered verifier if the attached media is the desired one or not.
void getDetectedDevices(MediaAccessId accessId, 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 ...
Pathname localRoot(MediaAccessId accessId) const
Return the local directory that corresponds to medias url, no matter if media isAttached or not.
Easy-to use interface to the ZYPP dependency resolver.
Definition: CodePitfalls.doc:1
MediaAccessId open(const Url &url, const Pathname &preferred_attach_point="")
Opens the media access for specified with the url.
zypp::RW_pointer< MediaAccess > MediaAccessRef
Definition: MediaManager.h:36
static time_t getMountTableMTime()
Get the modification time of the /etc/mtab file.
Url manipulation class.
Definition: Url.h:87
void delVerifier(MediaAccessId accessId)
Remove verifier for specified media id.
void releaseFile(MediaAccessId accessId, const Pathname &filename) const
FIXME: see MediaAccess class.
void close(MediaAccessId accessId)
Close the media access with specified id.
#define DBG
Definition: Logger.h:78
std::string protocol(MediaAccessId accessId) const
Query the protocol name used by the media access handler.
static std::vector< MountEntry > getMountEntries()
Get current mount entries from /etc/mtab file.
bool isUseableAttachPoint(const Pathname &path, bool mtab=true) const
Check if the specified path is useable as attach point.