RepoManager.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_REPOMANAGER_H
#define ZYPP_REPOMANAGER_H
 
#include <iosfwd>
#include <list>
 
#include <zypp/base/PtrTypes.h>
#include <zypp/base/Iterator.h>
#include <zypp/base/Flags.h>
 
#include <zypp/Pathname.h>
#include <zypp/ZConfig.h>
#include <zypp/RepoInfo.h>
#include <zypp/repo/RepoException.h>
#include <zypp/repo/RepoType.h>
#include <zypp/repo/ServiceType.h>
#include <zypp/ServiceInfo.h>
#include <zypp/RepoStatus.h>
#include <zypp/RepoManagerOptions.h>
#include <utility>
#include <zypp-core/ui/ProgressData>
 
namespace zypp
{ 
 
   std::list<RepoInfo> readRepoFile(const Url & repo_file);
 
  class RepoManager
  {
    friend std::ostream & operator<<( std::ostream & str, const RepoManager & obj );
 
  public:
    struct Impl;
 
    using ServiceSet = std::set<ServiceInfo>;
    using ServiceConstIterator = ServiceSet::const_iterator;
    using ServiceSizeType = ServiceSet::size_type;
 
    using RepoSet = std::set<RepoInfo>;
    using RepoConstIterator = RepoSet::const_iterator;
    using RepoSizeType = RepoSet::size_type;
 
  public:
   RepoManager( RepoManagerOptions options = RepoManagerOptions() );
    ~RepoManager();
 
    enum RawMetadataRefreshPolicy
    {
      RefreshIfNeeded,
      RefreshForced,
      RefreshIfNeededIgnoreDelay
    };
 
    enum CacheBuildPolicy
    {
      BuildIfNeeded,
      BuildForced
    };
 
    enum RefreshServiceBit
    {
      RefreshService_restoreStatus      = (1<<0),       
      RefreshService_forceRefresh       = (1<<1),       
    };
    ZYPP_DECLARE_FLAGS(RefreshServiceFlags,RefreshServiceBit);
 
    using RefreshServiceOptions = RefreshServiceFlags;
 
 
    bool repoEmpty() const;
    RepoSizeType repoSize() const;
    RepoConstIterator repoBegin() const;
    RepoConstIterator repoEnd() const;
    Iterable<RepoConstIterator> repos() const;
 
    std::list<RepoInfo> knownRepositories() const
    { return std::list<RepoInfo>(repoBegin(),repoEnd()); }
 
    RepoInfo getRepo( const std::string & alias ) const;
    RepoInfo getRepo( const RepoInfo & info_r ) const
    { return getRepo( info_r.alias() ); }
 
    bool hasRepo( const std::string & alias ) const;
    bool hasRepo( const RepoInfo & info_r ) const
    { return hasRepo( info_r.alias() ); }
 
    static std::string makeStupidAlias( const Url & url_r = Url() );
 
    RepoStatus metadataStatus( const RepoInfo &info ) const;
 
    enum RefreshCheckStatus {
      REFRESH_NEEDED,  
      REPO_UP_TO_DATE, 
      REPO_CHECK_DELAYED     
    };
 
    RefreshCheckStatus checkIfToRefreshMetadata( const RepoInfo &info,
                                   const Url &url,
                                   RawMetadataRefreshPolicy policy = RefreshIfNeeded);
 
    Pathname metadataPath( const RepoInfo &info ) const;
 
 
    Pathname packagesPath( const RepoInfo &info ) const;
 
 
   void refreshMetadata( const RepoInfo &info,
                         RawMetadataRefreshPolicy policy = RefreshIfNeeded,
                         const ProgressData::ReceiverFnc & progressrcv = ProgressData::ReceiverFnc() );
 
   void cleanMetadata( const RepoInfo &info,
                       const ProgressData::ReceiverFnc & progressrcv = ProgressData::ReceiverFnc() );
 
   void cleanPackages( const RepoInfo &info,
                       const ProgressData::ReceiverFnc & progressrcv = ProgressData::ReceiverFnc() );
 
    RepoStatus cacheStatus( const RepoInfo &info ) const;
 
   void buildCache( const RepoInfo &info,
                    CacheBuildPolicy policy = BuildIfNeeded,
                    const ProgressData::ReceiverFnc & progressrcv = ProgressData::ReceiverFnc() );
 
   void cleanCache( const RepoInfo &info,
                    const ProgressData::ReceiverFnc & progressrcv = ProgressData::ReceiverFnc() );
 
    bool isCached( const RepoInfo &info ) const;
 
 
   void loadFromCache( const RepoInfo &info,
                       const ProgressData::ReceiverFnc & progressrcv = ProgressData::ReceiverFnc() );
 
   void cleanCacheDirGarbage( const ProgressData::ReceiverFnc & progressrcv = ProgressData::ReceiverFnc() );
 
   repo::RepoType probe( const Url & url, const Pathname & path ) const;
   repo::RepoType probe( const Url & url ) const;
 
 
   void addRepository( const RepoInfo &info,
                       const ProgressData::ReceiverFnc & progressrcv = ProgressData::ReceiverFnc() );
 
    void addRepositories( const Url &url,
                         const ProgressData::ReceiverFnc & progressrcv = ProgressData::ReceiverFnc() );
    void removeRepository( const RepoInfo & info,
                           const ProgressData::ReceiverFnc & progressrcv = ProgressData::ReceiverFnc() );
 
    void modifyRepository( const std::string &alias,
                           const RepoInfo & newinfo,
                           const ProgressData::ReceiverFnc & progressrcv = ProgressData::ReceiverFnc() );
    void modifyRepository( const RepoInfo & newinfo,
                           const ProgressData::ReceiverFnc & progressrcv = ProgressData::ReceiverFnc() )
    { modifyRepository( newinfo.alias(), newinfo, progressrcv ); }
 
    RepoInfo getRepositoryInfo( const std::string &alias,
                                const ProgressData::ReceiverFnc & progressrcv = ProgressData::ReceiverFnc() );
 
    RepoInfo getRepositoryInfo( const Url & url,
                                const url::ViewOption & urlview = url::ViewOption::DEFAULTS,
                                const ProgressData::ReceiverFnc & progressrcv = ProgressData::ReceiverFnc() );
 
 
    bool serviceEmpty() const;
 
    ServiceSizeType serviceSize() const;
 
    ServiceConstIterator serviceBegin() const;
 
    ServiceConstIterator serviceEnd() const;
 
    Iterable<ServiceConstIterator> services() const;
 
    std::list<ServiceInfo> knownServices() const
    { return std::list<ServiceInfo>(serviceBegin(),serviceEnd()); }
 
    ServiceInfo getService( const std::string & alias ) const;
 
    bool hasService( const std::string & alias ) const;
 
    repo::ServiceType probeService( const Url &url ) const;
 
    void addService( const std::string & alias, const Url& url );
 
    void addService( const ServiceInfo & service );
 
    void removeService( const std::string & alias );
    void removeService( const ServiceInfo & service );
 
 
    void refreshServices( const RefreshServiceOptions & options_r = RefreshServiceOptions() );
 
    void refreshService( const std::string & alias, const RefreshServiceOptions & options_r = RefreshServiceOptions() );
    void refreshService( const ServiceInfo & service, const RefreshServiceOptions & options_r = RefreshServiceOptions() );
 
    void modifyService( const std::string & oldAlias, const ServiceInfo & service );
    void modifyService( const ServiceInfo & service )
    { modifyService( service.alias(), service ); }
 
    void refreshGeoIp ( const RepoInfo::url_set &urls );
 
  private:
    struct MatchServiceAlias
    {
      public:
        MatchServiceAlias( std::string  alias_ ) : alias(std::move(alias_)) {}
        bool operator()( const RepoInfo & info ) const
        { return info.service() == alias; }
      private:
        std::string alias;
    };
 
  public:
 
    template<typename OutputIterator>
    void getRepositoriesInService( const std::string & alias,
                                   OutputIterator out ) const
    {
      MatchServiceAlias filter(alias);
 
      std::copy( boost::make_filter_iterator( filter, repoBegin(), repoEnd() ),
                 boost::make_filter_iterator( filter, repoEnd(), repoEnd() ),
                 out);
    }
 
  private:
    RWCOW_pointer<Impl> _pimpl;
  };
  ZYPP_DECLARE_OPERATORS_FOR_FLAGS(RepoManager::RefreshServiceFlags);
 
  std::ostream & operator<<( std::ostream & str, const RepoManager & obj );
 
  inline Iterable<RepoManager::RepoConstIterator> RepoManager::repos() const
  { return makeIterable( repoBegin(), repoEnd() ); }
 
  inline Iterable<RepoManager::ServiceConstIterator> RepoManager::services() const
  { return makeIterable( serviceBegin(), serviceEnd() ); }
 
} // namespace zypp
#endif // ZYPP2_REPOMANAGER_H