RepoManager.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_REPOMANAGER_H
#define ZYPP_REPOMANAGER_H
 
#include <iosfwd>
#include <list>
 
#include <zypp-core/base/PtrTypes.h>
#include <zypp-core/base/Iterator.h>
#include <zypp-core/base/Flags.h>
 
#include <zypp-core/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/RepoManagerFlags.h>
#include <zypp/RepoManagerOptions.h>
#include <utility>
#include <zypp-core/ui/ProgressData>
#include <zypp-core/TriBool.h>

namespace zypp
{ 

   std::list<RepoInfo> readRepoFile(const Url & repo_file) ZYPP_API;

  class ZYPP_API 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();
 
    using RawMetadataRefreshPolicy = RepoManagerFlags::RawMetadataRefreshPolicy;
    static constexpr RawMetadataRefreshPolicy RefreshIfNeeded             = RepoManagerFlags::RefreshIfNeeded;
    static constexpr RawMetadataRefreshPolicy RefreshForced               = RepoManagerFlags::RefreshForced;
    static constexpr RawMetadataRefreshPolicy RefreshIfNeededIgnoreDelay  = RepoManagerFlags::RefreshIfNeededIgnoreDelay;
 
    using CacheBuildPolicy = RepoManagerFlags::CacheBuildPolicy;
    static constexpr CacheBuildPolicy BuildIfNeeded = CacheBuildPolicy::BuildIfNeeded;
    static constexpr CacheBuildPolicy BuildForced   = CacheBuildPolicy::BuildForced;

    using RefreshServiceBit = RepoManagerFlags::RefreshServiceBit;
    static constexpr RefreshServiceBit RefreshService_restoreStatus = RefreshServiceBit::RefreshService_restoreStatus;
    static constexpr RefreshServiceBit RefreshService_forceRefresh  = RefreshServiceBit::RefreshService_forceRefresh;
 
    using RefreshServiceFlags = RepoManagerFlags::RefreshServiceFlags;

    using RefreshServiceOptions = RepoManagerFlags::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;
 
    using RefreshCheckStatus = RepoManagerFlags::RefreshCheckStatus;
    static constexpr RefreshCheckStatus REFRESH_NEEDED     = RefreshCheckStatus::REFRESH_NEEDED;     
    static constexpr RefreshCheckStatus REPO_UP_TO_DATE    = RefreshCheckStatus::REPO_UP_TO_DATE;    
    static constexpr RefreshCheckStatus REPO_CHECK_DELAYED = RefreshCheckStatus::REPO_CHECK_DELAYED; 

    RefreshCheckStatus checkIfToRefreshMetadata( const RepoInfo &info,
                                   const Url &url,
                                   RawMetadataRefreshPolicy policy = RefreshIfNeeded);

    RefreshCheckStatus checkIfToRefreshMetadata( const RepoInfo &info,
                                   const zypp::MirroredOrigin &origin,
                                   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 addRepository( const RepoInfo &info, const TriBool & forcedProbe,
                       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;
  };


  std::ostream & operator<<( std::ostream & str, const RepoManager & obj ) ZYPP_API;

  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