repomanager.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_NG_REPOMANAGER_INCLUDED
#define ZYPP_NG_REPOMANAGER_INCLUDED
 
#include <utility>
#include <optional>
 
#include <zypp/RepoManagerFlags.h>
#include <zypp/RepoManagerOptions.h>
#include <zypp/RepoStatus.h>
 
#include <zypp/repo/RepoException.h>
#include <zypp/repo/PluginRepoverification.h>
#include <zypp/ng/workflows/logichelpers.h>
 
#include <zypp-core/base/Gettext.h>
#include <zypp-core/base/DefaultIntegral>
#include <zypp-core/base/NonCopyable.h>
#include <zypp-core/fs/PathInfo.h>
#include <zypp-core/ui/progressdata.h>
#include <zypp-core/zyppng/base/Base>
#include <zypp-core/zyppng/base/zyppglobal.h>
#include <zypp-core/zyppng/pipelines/expected.h>
 
namespace zyppng {
 
  using RepoInfo            = zypp::RepoInfo;
  using RepoStatus          = zypp::RepoStatus;
  using RepoInfoList        = zypp::RepoInfoList;
  using ServiceInfo         = zypp::ServiceInfo;
  using RepoManagerOptions  = zypp::RepoManagerOptions;
  using PluginRepoverification = zypp_private::repo::PluginRepoverification;
  ZYPP_FWD_DECL_TYPE_WITH_REFS( Context );
  ZYPP_FWD_DECL_TYPE_WITH_REFS( SyncContext );
  ZYPP_FWD_DECL_TYPE_WITH_REFS( ProgressObserver );
  ZYPP_FWD_DECL_TEMPL_TYPE_WITH_REFS_ARG1 ( RepoManager, ZyppContextRefType );
 
  using SyncRepoManager    = RepoManager<SyncContextRef>;
  using SyncRepoManagerRef = RepoManagerRef<SyncContextRef>;
 
  using AsyncRepoManager    = RepoManager<ContextRef>;
  using AsyncRepoManagerRef = RepoManagerRef<ContextRef>;

  inline bool isTmpRepo( const RepoInfo & info_r )
  { return( info_r.filepath().empty() && info_r.usesAutoMetadataPaths() ); }
 
  inline expected<void> assert_alias(const RepoInfo &info)
  {
    if ( info.alias().empty() )
      return expected<void>::error( ZYPP_EXCPT_PTR(zypp::repo::RepoNoAliasException( info ) ) );
    // bnc #473834. Maybe we can match the alias against a regex to define
    // and check for valid aliases
    if ( info.alias()[0] == '.')
      return expected<void>::error( ZYPP_EXCPT_PTR( zypp::repo::RepoInvalidAliasException(
        info, _("Repository alias cannot start with dot."))) );
 
    return expected<void>::success();
  }
 
  inline expected<void> assert_alias(const ServiceInfo &info) {
    if (info.alias().empty())
      return expected<void>::error( ZYPP_EXCPT_PTR(zypp::repo::ServiceNoAliasException(info)));
    // bnc #473834. Maybe we can match the alias against a regex to define
    // and check for valid aliases
    if (info.alias()[0] == '.')
      return expected<void>::error( ZYPP_EXCPT_PTR(zypp::repo::ServiceInvalidAliasException(
                   info, _("Service alias cannot start with dot."))));
 
    return expected<void>::success();
  }

  template <class Iterator>
  inline bool foundAliasIn( const std::string & alias_r, Iterator begin_r, Iterator end_r )
  {
    for_( it, begin_r, end_r )
      if ( it->alias() == alias_r )
      return true;
    return false;
  }

  template <class Container>
  inline bool foundAliasIn( const std::string & alias_r, const Container & cont_r )
  { return foundAliasIn( alias_r, cont_r.begin(), cont_r.end() ); }

  template <class Iterator>
  inline Iterator findAlias( const std::string & alias_r, Iterator begin_r, Iterator end_r )
  {
    for_( it, begin_r, end_r )
      if ( it->alias() == alias_r )
      return it;
    return end_r;
  }

  template <class Container>
  inline typename Container::iterator findAlias( const std::string & alias_r, Container & cont_r )
  { return findAlias( alias_r, cont_r.begin(), cont_r.end() ); }

  template <class Container>
  inline typename Container::const_iterator findAlias( const std::string & alias_r, const Container & cont_r )
  { return findAlias( alias_r, cont_r.begin(), cont_r.end() ); }
 

  std::string filenameFromAlias( const std::string & alias_r, const std::string & stem_r );

  struct RepoCollector : private zypp::base::NonCopyable
  {
    RepoCollector()
    {}
 
    RepoCollector(std::string  targetDistro_)
      : targetDistro(std::move(targetDistro_))
    {}
 
    bool collect( const RepoInfo &repo );
 
    RepoInfoList repos;
    std::string targetDistro;
  };


  expected<std::list<RepoInfo>> repositories_in_file( const zypp::Pathname & file );

 
  expected<void> assert_urls( const RepoInfo & info );
 
  inline expected<void> assert_url( const ServiceInfo & info )
  {
    if ( ! info.url().isValid() )
      return expected<void>::error( ZYPP_EXCPT_PTR ( zypp::repo::ServiceNoUrlException( info ) ) );
    return expected<void>::success();
  }

  inline expected<zypp::Pathname> rawcache_path_for_repoinfo( const RepoManagerOptions &opt, const RepoInfo &info )
  {
    using namespace zyppng::operators;
    return assert_alias(info) | and_then( [&](){ return make_expected_success( isTmpRepo( info ) ? info.metadataPath() : opt.repoRawCachePath / info.escaped_alias()); });
  }

  inline expected<zypp::Pathname> rawproductdata_path_for_repoinfo( const RepoManagerOptions &opt, const RepoInfo &info )
  {
    using namespace zyppng::operators;
    return rawcache_path_for_repoinfo( opt, info ) | and_then( [&]( zypp::Pathname p ) { return make_expected_success( p / info.path() ); } );
  }

  inline expected<zypp::Pathname> packagescache_path_for_repoinfo( const RepoManagerOptions &opt, const RepoInfo &info )
  {
    using namespace zyppng::operators;
    return assert_alias(info) |
    and_then([&](){ return make_expected_success(isTmpRepo( info ) ? info.packagesPath() : opt.repoPackagesCachePath / info.escaped_alias()); });
  }

  inline expected<zypp::Pathname> solv_path_for_repoinfo( const RepoManagerOptions &opt, const RepoInfo &info )
  {
    using namespace zyppng::operators;
    return assert_alias(info) |
    and_then([&](){ return make_expected_success(isTmpRepo( info ) ? info.metadataPath().dirname() / "%SLV%" : opt.repoSolvCachePath / info.escaped_alias()); });
  }


  class ServiceCollector
  {
  public:
    using ServiceSet = std::set<ServiceInfo>;
 
    ServiceCollector( ServiceSet & services_r )
      : _services( services_r )
    {}
 
    bool operator()( const ServiceInfo & service_r ) const
    {
      _services.insert( service_r );
      return true;
    }
 
  private:
    ServiceSet & _services;
  };


  bool autoPruneInDir( const zypp::Pathname & path_r );

  template <typename ZyppContextRefType>
  class RepoManager : public Base, private MaybeAsyncMixin<std::is_same_v<ZyppContextRefType, ContextRef>>
  {
    ZYPP_ADD_PRIVATE_CONSTR_HELPER ();
    ZYPP_ENABLE_MAYBE_ASYNC_MIXIN( (std::is_same_v<ZyppContextRefType, ContextRef>) );
 
  public:
 
    using ContextRefType      = ZyppContextRefType;
    using ContextType         = typename ZyppContextRefType::element_type;
 
    using RawMetadataRefreshPolicy = zypp::RepoManagerFlags::RawMetadataRefreshPolicy;
    using CacheBuildPolicy = zypp::RepoManagerFlags::CacheBuildPolicy;
 
 
    using RefreshCheckStatus = zypp::RepoManagerFlags::RefreshCheckStatus;

    using RefreshServiceBit     = zypp::RepoManagerFlags::RefreshServiceBit;
    using RefreshServiceOptions = zypp::RepoManagerFlags::RefreshServiceOptions;
 
 
    ZYPP_DECL_PRIVATE_CONSTR_ARGS (RepoManager, ZyppContextRefType zyppCtx, RepoManagerOptions opt  );
 
    template < typename ...Args >
    inline static expected<std::shared_ptr<RepoManager<ZyppContextRefType>>> create ( Args && ...args ) {
      using namespace zyppng::operators;
      auto mgr =  std::make_shared< RepoManager<ZyppContextRefType> >( private_constr_t{}, std::forward<Args>(args)... );
      return mgr->initialize() | and_then( [mgr](){ return make_expected_success(mgr); } );
    }
 
  public:

    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;
    };

    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;
 
 
    virtual ~RepoManager();
 
  public:
 
    expected<void> initialize ();
 
    ContextRefType zyppContext() const {
      return _zyppContext;
    }
 
    const RepoManagerOptions &options() const;
 
    bool repoEmpty() const             { return repos().empty(); }
    RepoSizeType repoSize() const   { return repos().size(); }
    RepoConstIterator repoBegin() const       { return repos().begin(); }
    RepoConstIterator repoEnd() const   { return repos().end(); }
 
    bool hasRepo( const std::string & alias ) const
    { return foundAliasIn( alias, repos() ); }
 
    RepoInfo getRepo( const std::string & alias ) const
    {
      RepoConstIterator it( findAlias( alias, repos() ) );
      return it == repos().end() ? RepoInfo::noRepo : *it;
    }
 
  public:
    expected<zypp::Pathname> metadataPath( const RepoInfo & info ) const
    { return rawcache_path_for_repoinfo( _options, info ); }
 
    expected<zypp::Pathname> packagesPath( const RepoInfo & info ) const
    { return packagescache_path_for_repoinfo( _options, info ); }
 
    static expected<RepoStatus> metadataStatus( const RepoInfo & info, const RepoManagerOptions &options );
    expected<RepoStatus> metadataStatus( const RepoInfo & info ) const;
 
    expected<void> cleanMetadata( const RepoInfo & info, ProgressObserverRef myProgress = nullptr );
 
    expected<void> cleanPackages( const RepoInfo & info, ProgressObserverRef myProgress = nullptr , bool isAutoClean = false );
 
    static zypp::repo::RepoType probeCache( const zypp::Pathname & path_r );
 
    expected<void> cleanCacheDirGarbage( ProgressObserverRef myProgress = nullptr );
 
    expected<void> cleanCache( const RepoInfo & info, ProgressObserverRef myProgress = nullptr );
 
    expected<bool> isCached( const RepoInfo & info ) const
    {
      using namespace zyppng::operators;
      return solv_path_for_repoinfo( _options, info )
          | and_then( [&]( zypp::Pathname solvPath) { return make_expected_success( zypp::PathInfo(solvPath / "solv").isExist()); } );
    }
 
    expected<RepoStatus> cacheStatus( const RepoInfo & info ) const
    { return cacheStatus( info, _options ); }
 
    static expected<RepoStatus> cacheStatus( const RepoInfo & info, const RepoManagerOptions &options )
    {
      using namespace zyppng::operators;
      return solv_path_for_repoinfo( options, info )
      | and_then( [&]( zypp::Pathname solvPath) {
        return make_expected_success ( RepoStatus::fromCookieFile(solvPath / "cookie") );
      });
    }
 
    expected<void> loadFromCache( const RepoInfo & info, ProgressObserverRef myProgress = nullptr );
 
    expected<RepoInfo> addProbedRepository( RepoInfo info, zypp::repo::RepoType probedType );
 
    expected<void> removeRepository( const RepoInfo & info, ProgressObserverRef myProgress = nullptr );
 
    expected<RepoInfo> modifyRepository( const std::string & alias, const RepoInfo & newinfo_r, ProgressObserverRef myProgress = nullptr );
 
    expected<RepoInfo> getRepositoryInfo( const std::string & alias );
    expected<RepoInfo> getRepositoryInfo( const zypp::Url & url, const zypp::url::ViewOption &urlview );
 
    expected<RefreshCheckStatus> checkIfToRefreshMetadata( const RepoInfo & info, const zypp::MirroredOrigin &origin, RawMetadataRefreshPolicy policy );
 
    expected<RefreshCheckStatus> checkIfToRefreshMetadata( const RepoInfo & info, const zypp::Url & url, RawMetadataRefreshPolicy policy ) {
      return checkIfToRefreshMetadata ( info, zypp::MirroredOrigin(url), policy );
    }

    expected<void> refreshMetadata( const RepoInfo & info, RawMetadataRefreshPolicy policy, ProgressObserverRef myProgress = nullptr  );
 
    std::vector<std::pair<RepoInfo, expected<void> > > refreshMetadata(std::vector<RepoInfo> infos, RawMetadataRefreshPolicy policy, ProgressObserverRef myProgress = nullptr  );
 
    expected<zypp::repo::RepoType> probe( const zypp::MirroredOrigin &origin, const zypp::Pathname & path = zypp::Pathname() ) const;
 
    expected<void> buildCache( const RepoInfo & info, CacheBuildPolicy policy, ProgressObserverRef myProgress = nullptr );

    expected<RepoInfo> addRepository( const RepoInfo & info, const ProgressObserverRef myProgress = nullptr, const zypp::TriBool & forcedProbe = zypp::indeterminate );
 
    expected<void> addRepositories( const zypp::Url & url, ProgressObserverRef myProgress = nullptr );
 
  public:
    bool serviceEmpty() const                       { return _services.empty(); }
    ServiceSizeType serviceSize() const               { return _services.size(); }
    ServiceConstIterator serviceBegin() const   { return _services.begin(); }
    ServiceConstIterator serviceEnd() const       { return _services.end(); }
 
    bool hasService( const std::string & alias ) const
    { return foundAliasIn( alias, _services ); }
 
    ServiceInfo getService( const std::string & alias ) const
    {
      ServiceConstIterator it( findAlias( alias, _services ) );
      return it == _services.end() ? ServiceInfo::noService : *it;
    }
 
  public:
 
    expected<zypp::repo::ServiceType> probeService( const zypp::Url & url ) const;
 
    expected<void> addService( const ServiceInfo & service );
    expected<void> addService( const std::string & alias, const zypp::Url & url )
    { return addService( ServiceInfo( alias, url ) ); }
 
    expected<void> removeService( const std::string & alias );
    expected<void> removeService( const ServiceInfo & service )
    { return removeService( service.alias() ); }
 
    expected<void> refreshService( const std::string & alias, const RefreshServiceOptions & options_r );
    expected<void> refreshService( const ServiceInfo & service, const RefreshServiceOptions & options_r )
    {  return refreshService( service.alias(), options_r ); }
 
    expected<void> refreshServices( const RefreshServiceOptions & options_r );
 
    expected<void> modifyService( const std::string & oldAlias, const ServiceInfo & newService );
 
    static expected<void> touchIndexFile( const RepoInfo & info, const RepoManagerOptions &options );
 
    expected<void> setCacheStatus( const RepoInfo & info, const RepoStatus & status )
    {
      using namespace zyppng::operators;
      return solv_path_for_repoinfo( _options, info )
      | and_then( [&]( zypp::Pathname base ){
        try {
          zypp::filesystem::assert_dir(base);
          status.saveToCookieFile( base / "cookie" );
        } catch ( const zypp::Exception &e ) {
          return expected<void>::error( std::make_exception_ptr(e) );
        }
        return expected<void>::success();
      });
    }

    expected<void> refreshGeoIp ( const RepoInfo::url_set &urls );
 
    template<typename OutputIterator>
    void getRepositoriesInService( const std::string & alias, OutputIterator out ) const
    {
      MatchServiceAlias filter( alias );
      std::copy( boost::make_filter_iterator( filter, repos().begin(), repos().end() ),
        boost::make_filter_iterator( filter, repos().end(), repos().end() ),
        out);
    }
 
    zypp::Pathname generateNonExistingName( const zypp::Pathname & dir, const std::string & basefilename ) const;
 
    std::string generateFilename( const RepoInfo & info ) const
    { return filenameFromAlias( info.alias(), "repo" ); }
 
    std::string generateFilename( const ServiceInfo & info ) const
    { return filenameFromAlias( info.alias(), "service" ); }
 
 
  protected:
    expected<void> saveService( ServiceInfo & service ) const;
    expected<void> touchIndexFile( const RepoInfo & info );
 
  protected:
    expected<void> init_knownServices();
    expected<void> init_knownRepositories();
 
  public:
    const RepoSet & repos() const { return _reposX; }
    RepoSet & reposManip()        { if ( ! _reposDirty ) _reposDirty = true; return _reposX; }
 
  public:
    PluginRepoverification pluginRepoverification() const
    { return _pluginRepoverification; }
 
  protected:
    ContextRefType      _zyppContext;
    RepoManagerOptions        _options;
    RepoSet              _reposX;
    ServiceSet                _services;
    PluginRepoverification _pluginRepoverification;
    zypp::DefaultIntegral<bool,false> _reposDirty;
  };
}
 
#endif //ZYPP_NG_REPOMANAGER_INCLUDED