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/ProgressData.h"

namespace zypp
{ 

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

  struct RepoManagerOptions
  {
    RepoManagerOptions( const Pathname & root_r = Pathname() );

    static RepoManagerOptions makeTestSetup( const Pathname & root_r );

    Pathname repoCachePath;
    Pathname repoRawCachePath;
    Pathname repoSolvCachePath;
    Pathname repoPackagesCachePath;
    Pathname knownReposPath;
    Pathname knownServicesPath;
    Pathname pluginsPath;
    bool probe;
    std::string servicesTargetDistro;

    Pathname rootDir;
  };



  class RepoManager
  {
    friend std::ostream & operator<<( std::ostream & str, const RepoManager & obj );

  public:
    class Impl;

    typedef std::set<ServiceInfo> ServiceSet;
    typedef ServiceSet::const_iterator ServiceConstIterator;
    typedef ServiceSet::size_type ServiceSizeType;

    typedef std::set<RepoInfo> RepoSet;
    typedef RepoSet::const_iterator RepoConstIterator;
    typedef RepoSet::size_type RepoSizeType;

  public:
   RepoManager( const RepoManagerOptions &options = RepoManagerOptions() );
    ~RepoManager();

    enum RawMetadataRefreshPolicy
    {
      RefreshIfNeeded,
      RefreshForced,
      RefreshIfNeededIgnoreDelay
    };

    enum CacheBuildPolicy
    {
      BuildIfNeeded,
      BuildForced
    };

    enum RefreshServiceBit
    {
      RefreshService_restoreStatus      = (1<<0)        
    };
    ZYPP_DECLARE_FLAGS(RefreshServiceFlags,RefreshServiceBit);

    typedef RefreshServiceFlags RefreshServiceOptions;


    bool repoEmpty() const;
    RepoSizeType repoSize() const;
    RepoConstIterator repoBegin() const;
    RepoConstIterator repoEnd() 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;

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

  private:
    struct MatchServiceAlias
    {
      public:
        MatchServiceAlias( const std::string & alias_ ) : alias(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 );

} // namespace zypp
#endif // ZYPP2_REPOMANAGER_H