MediaManager.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_MEDIA_MEDIAMANAGER_H
#define ZYPP_MEDIA_MEDIAMANAGER_H
 
#include <zypp/APIConfig.h>
#include <zypp/base/NonCopyable.h>
#include <zypp/base/PtrTypes.h>
#include <zypp/Pathname.h>
#include <zypp/PathInfo.h>
#include <zypp/Url.h>
#include <zypp-core/OnMediaLocation>
#include <zypp/media/MediaSource.h>
#include <zypp-media/MediaException>
 
#include <list>
 
 
namespace zypp::media
{
  class MediaHandler;
 
  typedef unsigned int  MediaNr;
 
 
  // forward declaration
  struct MountEntry;
  class MediaManager_Impl;
 
  //
  // CLASS NAME : MediaVerifierBase
  //
  class MediaVerifierBase //: private zypp::NonCopyable
  {
  public:
    MediaVerifierBase()
    {}
 
    virtual ~MediaVerifierBase()
    {}
 
    virtual std::string info() const;
 
    /*
    ** Check if the specified attached media contains
    ** the desired media (e.g. SLES10 CD1).
    */
    virtual bool isDesiredMedia(const MediaHandler &ref) const = 0;
  };
 
 
  //
  // CLASS NAME : NoVerifier
  //
  class NoVerifier : public MediaVerifierBase
  {
  public:
    NoVerifier(): MediaVerifierBase()
    {}
 
    ~NoVerifier() override
    {}
 
    std::string info() const override;
 
    /*
    ** Don't check if the specified attached media contains
    ** the desired media number. Always return true.
    */
    bool isDesiredMedia(const MediaHandler &ref) const override
    { return true; }
  };
 
 
  //
  // CLASS NAME : MediaVerifierRef
  //
  typedef zypp::RW_pointer<MediaVerifierBase> MediaVerifierRef;
 
 
  //
  // CLASS NAME : MediaManager
  //
  class MediaManager: private zypp::base::NonCopyable
  {
  public:
    MediaManager();
 
    ~MediaManager();
 
    MediaAccessId
    open(const Url &url, const Pathname & preferred_attach_point = "");
 
    void
    close(MediaAccessId accessId);
 
    bool
    isOpen(MediaAccessId accessId) const;
 
    std::string
    protocol(MediaAccessId accessId) const;
 
    bool
    downloads(MediaAccessId accessId) const;
 
    Url
    url(MediaAccessId accessId) const;
 
  public:
    void
    addVerifier(MediaAccessId accessId,
                const MediaVerifierRef &verifier);
 
    void
    delVerifier(MediaAccessId accessId);
 
  public:
    bool
    setAttachPrefix(const Pathname &attach_prefix);
 
    void
    attach(MediaAccessId accessId);
 
    void
    release(MediaAccessId accessId, const std::string & ejectDev = "");
 
    void
    releaseAll();
 
    void
    disconnect(MediaAccessId accessId);
 
    bool
    isAttached(MediaAccessId accessId) const;
 
    bool
    isSharedMedia(MediaAccessId accessId) const;
 
    bool
    isDesiredMedia(MediaAccessId accessId) const;
 
    bool
    isDesiredMedia(MediaAccessId           accessId,
                   const MediaVerifierRef &verifier) const;
 
    bool
    isChangeable(MediaAccessId accessId);
 
    Pathname
    localRoot(MediaAccessId accessId) const;
 
    Pathname
    localPath(MediaAccessId accessId, const Pathname & pathname) const;
 
  public:
 
    ZYPP_DEPRECATED void
    provideFile(MediaAccessId accessId,
                const Pathname &filename,
                const ByteCount &expectedFileSize) const;
 
    ZYPP_DEPRECATED void
    provideFile(MediaAccessId   accessId,
                const Pathname &filename ) const;
 
 
    void
    provideFile(MediaAccessId accessId,
      const OnMediaLocation &file ) const;
 
    void
    provideDir(MediaAccessId   accessId,
               const Pathname &dirname) const;
 
    void
    provideDirTree(MediaAccessId  accessId,
                   const Pathname &dirname) const;
 
    void
    releaseFile(MediaAccessId   accessId,
                const Pathname &filename) const;
 
    void
    releaseDir(MediaAccessId   accessId,
               const Pathname &dirname) const;
 
    void
    releasePath(MediaAccessId   accessId,
                const Pathname &pathname) const;
 
    void
    dirInfo(MediaAccessId           accessId,
            std::list<std::string> &retlist,
            const Pathname         &dirname,
            bool                    dots = true) const;
 
    void
    dirInfo(MediaAccessId           accessId,
            filesystem::DirContent &retlist,
            const Pathname         &dirname,
            bool                   dots = true) const;
 
    bool doesFileExist(MediaAccessId  accessId,
                       const Pathname & filename ) const;
 
    void
    getDetectedDevices(MediaAccessId accessId,
                       std::vector<std::string> & devices,
                       unsigned int & index) const;
 
    ZYPP_DEPRECATED void
    setDeltafile(MediaAccessId   accessId,
                const Pathname &filename ) const;
 
    void precacheFiles( MediaAccessId   accessId,
                       const std::vector<OnMediaLocation> &files);
 
  public:
    static time_t
    getMountTableMTime();
 
    static std::vector<MountEntry>
    getMountEntries();
 
    bool
    isUseableAttachPoint(const Pathname &path,
                         bool            mtab=true) const;
 
  private:
    friend class MediaHandler;
 
    AttachedMedia
    getAttachedMedia(MediaAccessId &accessId) const;
 
    AttachedMedia
    findAttachedMedia(const MediaSourceRef &media) const;
 
    void
    forceReleaseShared(const MediaSourceRef &media);
 
  private:
    static zypp::RW_pointer<MediaManager_Impl> m_impl;
  };
 
} // namespace zypp::media
 
#endif // ZYPP_MEDIA_MEDIAMANAGER_H
 
/*
** vim: set ts=2 sts=2 sw=2 ai et:
*/