18#include <zypp-media/MediaException> 
   22#include <zypp-media/Mount> 
   42      std::ostream & 
operator<<( std::ostream & str, 
const ManagedMedia & obj );
 
   57        ManagedMedia(
const ManagedMedia &) = 
delete;
 
   58        ManagedMedia &
operator=(
const ManagedMedia &) = 
delete;
 
   60        ManagedMedia(ManagedMedia &&m) noexcept
 
   61          : desired(m.desired), verifier(std::move(m.verifier)),
 
   62            _handler(std::move(m._handler)) {}
 
   64        static ManagedMedia makeManagedMedia ( 
const MirroredOrigin &origin_r, 
const Pathname &preferred_attach_point, 
const MediaVerifierRef &v )
 
   68            ERR << 
"Failed to create media handler" << std::endl;
 
   69            if ( origin_r.authority().isValid() )
 
   70              ZYPP_THROW( MediaSystemException( origin_r.authority().url(), 
"Failed to create media handler"));
 
   71            ZYPP_THROW( MediaException(
"Failed to create media handler") );
 
   73          return ManagedMedia( std::move(handler), v );
 
   76        ManagedMedia &operator= ( ManagedMedia &&other ) = 
default;
 
   78        operator bool ()
 const {
 
   79          return ( _handler ? 
true : 
false );
 
   82        inline MediaHandler &handler() {
 
   84              ZYPP_THROW(MediaNotOpenException(
"Accessing ManagedMedia after it was closed"));
 
   88        inline const MediaHandler &handler()
 const {
 
   90            ZYPP_THROW(MediaNotOpenException(
"Accessing ManagedMedia after it was closed"));
 
   94        std::ostream & 
dumpOn( std::ostream & str )
 const {
 
   96            return str << 
"ManagedMedia( closed )";
 
   98          str << _handler->protocol() << 
"(" << *_handler << 
")";
 
  112          catch (
const MediaException & excpt_r)
 
  115            WAR << 
"Close: " << *
this << 
" (" << excpt_r << 
")" << std::endl;
 
  118          MIL << 
"Close: " << *
this << 
" (OK)" << std::endl;
 
  124          if( !handler().isAttached())
 
  126            DBG << 
"checkAttached(" << 
id << 
") not attached" << std::endl;
 
  140            const auto &hdl = handler();
 
  142              desired = verifier->isDesiredMedia( handler() );
 
  143            } 
catch ( 
const zypp::Exception &e ) {
 
  146                media::MediaNotDesiredException newEx ( hdl.url() );
 
  153              DBG << 
"checkDesired(" << 
id << 
"): not desired (report by " << verifier->info() << 
")" << std::endl;
 
  154              ZYPP_THROW( MediaNotDesiredException( hdl.url() ) );
 
  157            DBG << 
"checkDesired(" << 
id << 
"): desired (report by " << verifier->info() << 
")" << std::endl;
 
  159            DBG << 
"checkDesired(" << 
id << 
"): desired (cached)" << std::endl;
 
  170          , verifier(std::move(v))
 
  171          , _handler ( std::move(h) )
 
  174        std::unique_ptr<MediaHandler>  _handler;
 
  177      std::ostream & 
operator<<( std::ostream & str, 
const ManagedMedia & obj ) {
 
  178        return obj.dumpOn( str );
 
  182      using ManagedMediaMap = std::map<MediaAccessId, ManagedMedia>;
 
  193      return std::string(
typeid((*
this)).name());
 
 
  201      return std::string(
"zypp::media::NoVerifier");
 
 
  230          ManagedMediaMap::iterator it;
 
  237              if( it->second && it->second.handler().dependsOnParent() )
 
  242                it->second.handler().resetParentId();
 
 
  269      inline ManagedMedia &
 
  272        ManagedMediaMap::iterator it( 
mediaMap.find(accessId));
 
 
  288      static inline MountEntries
 
 
  327      ManagedMedia tmp = ManagedMedia::makeManagedMedia( origin_r, preferred_attach_point, verifier );
 
  331      m_impl->mediaMap.insert( std::make_pair( nextId, std::move(tmp) ) );
 
  334      DBG << 
"Opened new media access using id " << nextId
 
 
  353      ManagedMediaMap::iterator m(
m_impl->mediaMap.begin());
 
  354      for( ; m != 
m_impl->mediaMap.end(); ++m)
 
  356        if( m->second.handler().dependsOnParent(accessId, 
true))
 
  359            m->second.handler().url().asString()
 
  364      DBG << 
"Close to access handler using id " 
  365          << accessId << 
" requested" << std::endl;
 
  367      ManagedMedia &ref( 
m_impl->findMM(accessId));
 
  370      m_impl->mediaMap.erase(accessId);
 
 
  377      ManagedMediaMap::iterator it( 
m_impl->mediaMap.find(accessId));
 
  378      return it != 
m_impl->mediaMap.end();
 
 
  385      ManagedMedia &ref( 
m_impl->findMM(accessId));
 
  387      return ref.handler().protocol();
 
 
  394      ManagedMedia &ref( 
m_impl->findMM(accessId));
 
  396      return ref.handler().downloads();
 
 
  403      ManagedMedia &ref( 
m_impl->findMM(accessId));
 
  405      return ref.handler().url();
 
 
  416      ManagedMedia &ref( 
m_impl->findMM(accessId));
 
  421      DBG << 
"MediaVerifier change: id=" << accessId << 
", verifier=" 
  422          << verifier->info() << std::endl;
 
 
  429      ManagedMedia &ref( 
m_impl->findMM(accessId));
 
  433      ref.verifier.swap(verifier);
 
  435      DBG << 
"MediaVerifier change: id=" << accessId << 
", verifier=" 
  436          << verifier->info() << std::endl;
 
 
  449      ManagedMedia &ref( 
m_impl->findMM(accessId));
 
  450      auto &hdl = ref.handler();
 
  452      DBG << 
"attach(id=" << accessId << 
")" << std::endl;
 
  458        ref.checkDesired(accessId);
 
  465        if (!hdl.hasMoreDevices())
 
  468        if (hdl.isAttached())
 
  472      MIL << 
"checkDesired(" << accessId << 
") of first device failed," 
  473        " going to try others with attach(true)" << std::endl;
 
  475      while (hdl.hasMoreDevices())
 
  481          ref.checkDesired(accessId);
 
  488          if (!hdl.hasMoreDevices())
 
  490            MIL << 
"No desired media found after trying all detected devices." << std::endl;
 
  495          DBG << 
"Skipping " << 
media.mediaSource->asString() << 
": not desired media." << std::endl;
 
  503          if (!hdl.hasMoreDevices())
 
  507          DBG << 
"Skipping " << 
media.mediaSource->asString() << 
" because of exception thrown by attach(true)" << std::endl;
 
  509          if (hdl.isAttached()) hdl.release();
 
 
  518      ManagedMedia &ref( 
m_impl->findMM(accessId));
 
  520      DBG << 
"release(id=" << accessId;
 
  521      if (!ejectDev.empty())
 
  522        DBG << 
", " << ejectDev;
 
  523      DBG << 
")" << std::endl;
 
  525      if(!ejectDev.empty())
 
  533        ManagedMediaMap::iterator m(
m_impl->mediaMap.begin());
 
  534        for( ; m != 
m_impl->mediaMap.end(); ++m)
 
  536          auto &hdl = m->second.handler();
 
  537          if( hdl.dependsOnParent(accessId, 
false))
 
  541              DBG << 
"Forcing release of handler depending on access id " 
  542                  << accessId << std::endl;
 
  543              m->second.desired  = 
false;
 
  554      ref.handler().release(ejectDev);
 
 
  561      MIL << 
"Releasing all attached media" << std::endl;
 
  562      auto releaseAction = []( 
MediaAccessId mId_r, ManagedMedia & mManagedMedia_r, 
bool ifDependsOnParent_r ) {
 
  563        auto & hdl = mManagedMedia_r.handler();
 
  564        if ( hdl.dependsOnParent() == ifDependsOnParent_r ) {
 
  566            if ( hdl.isAttached() ) {
 
  567              DBG << 
"Releasing media id " << mId_r << std::endl;
 
  568              mManagedMedia_r.desired = 
false;
 
  572              DBG << 
"Media id " << mId_r << 
" not attached " << std::endl;
 
  577            ERR << 
"Failed to release media id " << mId_r << std::endl;
 
  583      for ( 
auto & [ mId, mManagedMedia ] : 
m_impl->mediaMap ) {
 
  584        releaseAction( mId, mManagedMedia, 
true );
 
  587      for ( 
auto & [ mId, mManagedMedia ] : 
m_impl->mediaMap ) {
 
  588        releaseAction( mId, mManagedMedia, 
false );
 
  591      MIL << 
"Exit" << std::endl;
 
 
  598      ManagedMedia &ref( 
m_impl->findMM(accessId));
 
  600      ref.handler().disconnect();
 
 
  607      ManagedMedia &ref( 
m_impl->findMM(accessId));
 
  609      return ref.handler().isAttached();
 
 
  615      ManagedMedia &ref( 
m_impl->findMM(accessId));
 
  617      return ref.handler().isSharedMedia();
 
 
  624      ManagedMedia &ref( 
m_impl->findMM(accessId));
 
  626      if( !ref.handler().isAttached())
 
  633          ref.desired = ref.verifier->isDesiredMedia( ref.handler() );
 
  640      DBG << 
"isDesiredMedia(" << accessId << 
"): " 
  641          << (ref.desired ? 
"" : 
"not ")
 
  642          << 
"desired (report by " 
  643          << ref.verifier->info() << 
")" << std::endl;
 
 
  656      ManagedMedia &ref( 
m_impl->findMM(accessId));
 
  658      bool desired = 
false;
 
  659      if( ref.handler().isAttached())
 
  662          desired = v->isDesiredMedia( ref.handler() );
 
  669      DBG << 
"isDesiredMedia(" << accessId << 
"): " 
  670          << (desired ? 
"" : 
"not ")
 
  671          << 
"desired (report by " 
  672          << v->info() << 
")" << std::endl;
 
 
  680      return url(accessId).getScheme() == 
"cd" || 
url(accessId).getScheme() == 
"dvd";
 
 
  687      ManagedMedia &ref( 
m_impl->findMM(accessId));
 
  690      path = ref.handler().localRoot();
 
 
  699      ManagedMedia &ref( 
m_impl->findMM(accessId));
 
  702      path = ref.handler().localPath(pathname);
 
 
  709                              const ByteCount &expectedFileSize )
 const 
  711      ManagedMedia &ref( 
m_impl->findMM(accessId));
 
 
  725      ManagedMedia &ref( 
m_impl->findMM(accessId));
 
 
  735      ManagedMedia &ref( 
m_impl->findMM(accessId));
 
  737      ref.checkDesired(accessId);
 
  739      ref.handler().provideFile( file );
 
 
  747      ManagedMedia &ref( 
m_impl->findMM(accessId));
 
  749      ref.checkDesired(accessId);
 
  751      ref.deltafile = filename;
 
 
  756      ManagedMedia &ref( 
m_impl->findMM(accessId));
 
  758      ref.checkDesired(accessId);
 
  760      ref.handler().precacheFiles( files );
 
 
  768      ManagedMedia &ref( 
m_impl->findMM(accessId));
 
  770      ref.checkDesired(accessId);
 
  772      ref.handler().provideDir(dirname);
 
 
  780      ManagedMedia &ref( 
m_impl->findMM(accessId));
 
  782      ref.checkDesired(accessId);
 
  784      ref.handler().provideDirTree(dirname);
 
 
  792      ManagedMedia &ref( 
m_impl->findMM(accessId));
 
  794      ref.checkAttached(accessId);
 
  796      ref.handler().releaseFile(filename);
 
 
  804      ManagedMedia &ref( 
m_impl->findMM(accessId));
 
  806      ref.checkAttached(accessId);
 
  808      ref.handler().releaseDir(dirname);
 
 
  817      ManagedMedia &ref( 
m_impl->findMM(accessId));
 
  819      ref.checkAttached(accessId);
 
  821      ref.handler().releasePath(pathname);
 
 
  827                          std::list<std::string> &retlist,
 
  831      ManagedMedia &ref( 
m_impl->findMM(accessId));
 
  834      ref.checkAttached(accessId);
 
  836      ref.handler().dirInfo(retlist, dirname, dots);
 
 
  846      ManagedMedia &ref( 
m_impl->findMM(accessId));
 
  849      ref.checkAttached(accessId);
 
  851      ref.handler().dirInfo(retlist, dirname, dots);
 
 
  858      ManagedMedia &ref( 
m_impl->findMM(accessId));
 
  861      ref.checkAttached(accessId);
 
  863      return ref.handler().doesFileExist(filename);
 
 
  869                                     std::vector<std::string> & devices,
 
  870                                     unsigned int & index)
 const 
  872      ManagedMedia &ref( 
m_impl->findMM(accessId));
 
  873      return ref.handler().getDetectedDevices(devices, index);
 
 
  903      ManagedMediaMap::const_iterator m(
m_impl->mediaMap.begin());
 
  904      for( ; m != 
m_impl->mediaMap.end(); ++m)
 
  910          const std::string& our(path.
asString());
 
  918          if( mnt.size() > our.size()   &&
 
  919              mnt.at(our.size()) == 
'/' &&
 
  920             !mnt.compare(0, our.size(), our))
 
  935      MountEntries  entries( 
m_impl->getMountEntries());
 
  936      MountEntries::const_iterator e;
 
  937      for( e = entries.begin(); e != entries.end(); ++e)
 
  940        const std::string& our(path.
asString());
 
  948        if( mnt.size() > our.size()   &&
 
  949            mnt.at(our.size()) == 
'/' &&
 
  950           !mnt.compare(0, our.size(), our))
 
 
  965      ManagedMedia &ref( 
m_impl->findMM(accessId));
 
  967      return ref.handler().attachedMedia();
 
 
  977      ManagedMediaMap::const_iterator m(
m_impl->mediaMap.begin());
 
  978      for( ; m != 
m_impl->mediaMap.end(); ++m)
 
  980        if( !m->second.handler().isAttached())
 
 
  997      ManagedMediaMap::iterator m(
m_impl->mediaMap.begin());
 
  998      for( ; m != 
m_impl->mediaMap.end(); ++m)
 
 1000        if( !m->second.handler().isAttached())
 
 1006          m->second.handler().release();
 
 1007          m->second.desired  = 
false;
 
 
Store and operate with byte count.
Base class for Exception.
Manages a data source characterized by an authoritative URL and a list of mirror URLs.
const OriginEndpoint & authority() const
const zypp::Url & url() const
std::string asString() const
Returns a default string representation of the Url object.
Wrapper class for stat/lstat.
const std::string & asString() const
String representation.
bool empty() const
Test for an empty path.
std::list< DirEntry > DirContent
Returned by readdir.
SolvableSpec & operator=(const SolvableSpec &)=default
std::string numstring(char n, int w=0)
Easy-to use interface to the ZYPP dependency resolver.
std::ostream & dumpOn(std::ostream &str, const Capability &obj)
Wrapper for const correct access via Smart pointer types.
void swap(RW_pointer &rhs) noexcept
#define ZYPP_RETHROW(EXCPT)
Drops a logline and rethrows, updating the CodeLocation.
#define ZYPP_CAUGHT(EXCPT)
Drops a logline telling the Exception was caught (in order to handle it).
#define ZYPP_THROW(EXCPT)
Drops a logline and throws the Exception.