SourceImpl.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_SOURCE_SOURCEIMPL_H
#define ZYPP_SOURCE_SOURCEIMPL_H

#include <iosfwd>
#include <string>

#include "zypp/base/ReferenceCounted.h"
#include "zypp/base/NonCopyable.h"
#include "zypp/base/PtrTypes.h"
#include "zypp/base/ProvideNumericId.h"

#include "zypp/Source.h"
#include "zypp/ResStore.h"
#include "zypp/Pathname.h"
#include "zypp/CheckSum.h"
#include "zypp/media/MediaManager.h"
#include "zypp/source/MediaSet.h"
#include "zypp/TmpPath.h"

namespace zypp
{ 

  namespace source
  { 

    DEFINE_PTR_TYPE(SourceImpl);
    
    class SourceProber
    {
      public:
        SourceProber( media::MediaAccessId media_id, const Pathname &path )
          : _media_id(media_id), _path(path)
        {}
        
        virtual ~SourceProber()
        {}
        
        virtual bool operator()() = 0;

      protected:
        media::MediaAccessId _media_id;
        Pathname _path;
    };
    
    class SourceEventHandler
    {
      public:
        typedef boost::shared_ptr<SourceEventHandler> Ptr;
        SourceEventHandler( boost::function<void (int)> fnc )
        : _fnc(fnc)
        {
        
        };
        ~SourceEventHandler()
        {};
        void progress(int p)
        {
          if (_fnc)
            _fnc(p);
        }
      
      private:
        boost::function<void (int)> _fnc;
        int _file_size;
        int no_lines;
    };
    
    //
    //  CLASS NAME : SourceImpl
    //
    class SourceImpl : public base::ReferenceCounted
                     , public base::ProvideNumericId<SourceImpl,Source_Ref::NumericId>
                     , private base::NonCopyable
    {
      media::MediaManager media_mgr;

      friend std::ostream & operator<<( std::ostream & str, const SourceImpl & obj );

    public:
      void factoryCtor( const media::MediaId & media_r,
                        const Pathname & path_r,
                        const std::string & alias_r,
                        const Pathname cache_dir_r,
                        bool base_source, bool auto_refresh);

      class Verifier;

    public:

      const ResStore & resolvables(Source_Ref) const
      { return resolvables(); }
      const ResStore & resolvables() const;
      const ResStore resolvables(zypp::Resolvable::Kind kind) const;

      const Pathname provideFile(const Pathname & file,
                                 const unsigned media_nr = 1,
                                 bool cached = false,
                                 bool checkonly = false);
      const Pathname tryToProvideFile( const Pathname & file, const unsigned media_nr = 1 );

      const Pathname provideDirTree(const Pathname & path,
                                const unsigned media_nr = 1);

      const void releaseFile(const Pathname & file_r,
                             const unsigned media_nr = 1);

      const void releaseDir(const Pathname & path_r,
                            const unsigned media_nr = 1,
                            const bool recursive = false);

      const Pathname providePackage( Package::constPtr package );

      void dirInfo( const unsigned media_nr,
                    std::list<std::string> &retlist,
                    const Pathname         &path_r,
                    bool                    dots = true) const;

      void changeMedia(const media::MediaId & media_r, const Pathname & path_r);

      bool enabled() const;
      void enable();
      void disable();
      bool autorefresh() const;
      void setAutorefresh( bool enable_r );
      void refresh();

      virtual void storeMetadata(const Pathname & cache_dir_r);

      virtual Date timestamp() const;

      virtual std::string checksum() const;
      
      std::string alias (void) const
      { return _alias; }

      void setAlias (const std::string & alias)
      { _alias = alias; }

      virtual std::string id (void) const;
      virtual void setId (const std::string id_r);
      virtual unsigned priority (void) const;
      virtual void setPriority (unsigned p);
      virtual unsigned priorityUnsubscribed (void) const;
      virtual void setPriorityUnsubscribed (unsigned p);
      virtual bool subscribed (void) const;
      virtual void setSubscribed (bool s);
      virtual const Pathname & cacheDir (void);
      virtual const std::list<Pathname> publicKeys();

      virtual std::string type(void) const;

      Url url (void) const;
      void setUrl( const Url & url );
      bool remote () const;
      bool baseSource () const
      { return _base_source; }

      const Pathname & path (void) const;

      virtual unsigned numberOfMedia(void) const;

      virtual std::string vendor (void) const;

      virtual std::string unique_id (void) const;

      virtual std::string zmdName (void) const;
      virtual void setZmdName (const std::string name_r);
      virtual std::string zmdDescription (void) const;
      virtual void setZmdDescription (const std::string desc_r);

      virtual void redirect(unsigned media_nr, const Url & new_url);
      void reattach(const Pathname &attach_point);
      void release();

      virtual media::MediaVerifierRef verifier(unsigned media_nr);

      virtual std::set<zypp::Resolvable::Kind> resolvableKinds() const;
      
      Source_Ref selfSourceRef()
      { return Source_Ref( this ); }
    protected:


      const Pathname provideJustFile(const Pathname & path,
                                 const unsigned media_nr = 1,
                                 bool cached = false,
                                 bool checkonly = false);

      void copyLocalMetadata(const Pathname &src, const Pathname &dst) const;

      Pathname tmpMetadataDir() const;

        void resetMediaVerifier();
        
        void getPossiblyCachedMetadataFile( const Pathname &file_to_download, const Pathname &destination, const Pathname &cached_file, const CheckSum &checksum );

    protected:
      ResStore _store;
      Url _url;
      Pathname _path;
      bool _enabled;
      bool _autorefresh;
      std::string _alias;
      Pathname _cache_dir;
      std::string _id;
      unsigned _priority;
      unsigned _priority_unsubscribed;
      bool _subscribed;
      bool _base_source;

    private:
      mutable shared_ptr<filesystem::TmpDir> _tmp_metadata_dir_ptr;
      // no playground below this line ;)
    protected:
      SourceImpl();

      virtual void factoryInit();

      virtual ~SourceImpl();

      virtual std::ostream & dumpOn( std::ostream & str ) const;

      intrusive_ptr<MediaSet> _media_set;

    private:
      virtual void createResolvables(Source_Ref source_r);

      virtual ResStore provideResolvablesByKind(Source_Ref source_r, zypp::Resolvable::Kind kind);

      bool _res_store_initialized;

    public:
      bool resStoreInitialized () const
      { return _res_store_initialized; }

    private:
      struct null {};

      SourceImpl( const null & );

    public:
      static SourceImpl_Ptr nullimpl()
      {
        static SourceImpl_Ptr _nullimpl( new SourceImpl( null() ) );
        return _nullimpl;
      }

    };

    inline std::ostream & operator<<( std::ostream & str, const SourceImpl & obj )
    { return obj.dumpOn( str ); }


    class SourceImpl::Verifier : public media::MediaVerifierBase
      {
      public:
        Verifier (const std::string & vendor_r, const std::string & id_r, const media::MediaNr media_nr = 1);
        /*
         ** Check if the specified attached media contains
         ** the desired media number (e.g. SLES10 CD1).
         */
        virtual bool
        isDesiredMedia(const media::MediaAccessRef &ref);

      private:
        std::string _media_vendor;
        std::string _media_id;
        media::MediaNr _media_nr;
        SourceImpl_Ptr _source;
      };

  } // namespace source
} // namespace zypp
#endif // ZYPP_SOURCE_SOURCEIMPL_H

---