MediaHandler.h

Go to the documentation of this file.

 
/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_MEDIA_MEDIAHANDLERL_H
#define ZYPP_MEDIA_MEDIAHANDLERL_H
 
#include <iosfwd>
#include <string>
#include <list>
 
#include <zypp/Pathname.h>
#include <zypp/PathInfo.h>
#include <zypp/base/PtrTypes.h>
 
#include <zypp/Url.h>
 
#include <zypp/media/MediaSource.h>
#include <zypp/media/MediaException.h>
#include <zypp/APIConfig.h>
#include <zypp/OnMediaLocation.h>
 
namespace zypp {
  namespace media {
 
 
//
//      CLASS NAME : MediaHandler
class MediaHandler {
    friend std::ostream & operator<<( std::ostream & str, const MediaHandler & obj );
 
    public:
        typedef shared_ptr<MediaHandler> Ptr;
        typedef shared_ptr<const MediaHandler> constPtr;
 
        static bool setAttachPrefix(const Pathname &attach_prefix);
 
        static std::string getRealPath(const std::string &path);
        static Pathname    getRealPath(const Pathname    &path);
 
    private:
        static Pathname _attachPrefix;
 
        mutable
        MediaSourceRef  _mediaSource;
 
        AttachPointRef  _attachPoint;
 
        AttachPoint     _attachPointHint;
 
        Pathname        _relativeRoot;
 
        bool            _does_download;
 
        mutable time_t  _attach_mtime;
 
        mutable Pathname _deltafile;
 
    protected:
        const Url        _url;
 
        MediaAccessId    _parentId;
 
        friend class MediaAccess;
 
        bool             dependsOnParent(MediaAccessId parentId,
                                         bool exactIdMatch);
        bool             dependsOnParent();
 
        void             resetParentId();
 
        Pathname         attachPoint() const;
 
        void             setAttachPoint(const Pathname &path, bool temp);
 
        void             setAttachPoint(const AttachPointRef &ref);
 
        AttachPoint      attachPointHint() const;
 
        void             attachPointHint(const Pathname &path, bool temp);
 
        Pathname         createAttachPoint() const;
        Pathname         createAttachPoint(const Pathname &attach_root) const;
 
        void             removeAttachPoint();
 
        virtual bool     checkAttachPoint(const Pathname &apoint) const;
 
        static bool      checkAttachPoint(const Pathname &apoint,
                                          bool            empty_dir,
                                          bool            writeable);
 
        bool             isUseableAttachPoint(const Pathname &path,
                                              bool            mtab=true) const;
 
        std::string      mediaSourceName() const
        {
          return _mediaSource ? _mediaSource->name : "";
        }
 
        void             setMediaSource(const MediaSourceRef &ref);
 
        AttachedMedia
        findAttachedMedia(const MediaSourceRef &media) const;
 
        AttachedMedia    attachedMedia() const;
 
        bool             isSharedMedia() const;
 
        bool             checkAttached(bool matchMountFs) const;
 
        void             forceRelaseAllMedia(bool matchMountFs);
        void             forceRelaseAllMedia(const MediaSourceRef &ref,
                                             bool matchMountFs);
 
    protected:
 
        //
        // Real action interface to be overloaded by concrete handler.
        //
 
        virtual void attachTo(bool next = false) = 0;
 
        virtual void disconnectFrom() { return; }
 
        virtual void releaseFrom( const std::string & ejectDev = "" ) = 0;
 
        virtual void forceEject( const std::string & device ) {}
 
        virtual void getFile( const Pathname & filename, const ByteCount &expectedFileSize_r ) const;
 
 
        virtual void getFiles( const std::vector< std::pair<Pathname, ByteCount> > &files ) const;
 
        virtual void getFileCopy( const Pathname & srcFilename, const Pathname & targetFilename, const ByteCount &expectedFileSize_r ) const;
 
 
        virtual void getDir( const Pathname & dirname, bool recurse_r ) const = 0;
 
        virtual void getDirInfo( std::list<std::string> & retlist,
                                 const Pathname & dirname, bool dots = true ) const = 0;
 
        virtual void getDirInfo( filesystem::DirContent & retlist,
                                 const Pathname & dirname, bool dots = true ) const = 0;
 
        virtual bool getDoesFileExist( const Pathname & filename ) const = 0;
 
  protected:
 
        void getDirectoryYast( std::list<std::string> & retlist,
                               const Pathname & dirname, bool dots = true ) const;
 
        void getDirectoryYast( filesystem::DirContent & retlist,
                               const Pathname & dirname, bool dots = true ) const;
 
  public:
 
        MediaHandler ( const Url&       url_r,
                       const Pathname & attach_point_r,
                       const Pathname & urlpath_below_attachpoint_r,
                       const bool       does_download_r );
 
        virtual ~MediaHandler();
 
    public:
 
 
        //
        // MediaAccess interface. Does common checks and logging.
        // Invokes real action if necessary.
        //
 
        bool        downloads() const { return _does_download; }
 
        std::string protocol() const { return _url.getScheme(); }
 
        Url url() const { return _url; }
 
        void attach(bool next);
 
        virtual bool isAttached() const { return _mediaSource != nullptr; }
 
        Pathname localRoot() const;
 
         Pathname localPath( const Pathname & pathname ) const;
 
        void disconnect();
 
        void release( const std::string & ejectDev = "" );
 
        void provideFile( Pathname filename, const ByteCount &expectedFileSize_r ) const;
 
        void provideFileCopy( Pathname srcFilename, Pathname targetFilename, const ByteCount &expectedFileSize_r ) const;
 
        void provideDir( Pathname dirname ) const;
 
        void provideDirTree( Pathname dirname ) const;
 
        void releaseFile( const Pathname & filename ) const { return releasePath( filename ); }
 
        void releaseDir( const Pathname & dirname ) const { return releasePath( dirname ); }
 
        void releasePath( Pathname pathname ) const;
 
        /*
         * set a deltafile to be used in the next download
         */
        void setDeltafile( const Pathname &filename = Pathname()) const;
 
        /*
         * return the deltafile set with setDeltafile()
         */
        Pathname deltafile () const;
 
    public:
 
        void dirInfo( std::list<std::string> & retlist,
                      const Pathname & dirname, bool dots = true ) const;
 
        void dirInfo( filesystem::DirContent & retlist,
                      const Pathname & dirname, bool dots = true ) const;
 
        bool doesFileExist( const Pathname & filename ) const;
 
        virtual bool hasMoreDevices();
 
        virtual void
        getDetectedDevices(std::vector<std::string> & devices,
                           unsigned int & index) const;
 
        virtual void
        precacheFiles ( const std::vector< OnMediaLocation > &files );
};
 
 
  } // namespace media
} // namespace zypp
 
 
#endif // ZYPP_MEDIA_MEDIAHANDLERL_H