InstSrcManager.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                                                                      |
|                      __   __    ____ _____ ____                      |
|                      \ \ / /_ _/ ___|_   _|___ \                     |
|                       \ V / _` \___ \ | |   __) |                    |
|                        | | (_| |___) || |  / __/                     |
|                        |_|\__,_|____/ |_| |_____|                    |
|                                                                      |
|                               core system                            |
|                                                        (C) SuSE GmbH |
\----------------------------------------------------------------------/

  File:       InstSrcManager.h

  Author:     Michael Andres <ma@suse.de>
  Maintainer: Michael Andres <ma@suse.de>

/-*/
#ifndef InstSrcManager_h
#define InstSrcManager_h

#include <iosfwd>

#include <y2util/Url.h>

#include <y2pm/PMTypes.h>

#include <y2pm/InstSrcPtr.h>
#include <y2pm/InstSrcError.h>
#include <y2pm/PkgPubkeyCache.h>

//
//      CLASS NAME : InstSrcManager
class InstSrcManager {

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

  InstSrcManager & operator=( const InstSrcManager & );
  InstSrcManager            ( const InstSrcManager & );

  public:

    typedef InstSrcError Error;

    static const unsigned NO_RANK = unsigned(-1);

  private:

    friend class Y2PM;
    InstSrcManager( const bool autoEnable_r = true );
    void launch();
    ~InstSrcManager();

  private:

    static Pathname _cache_root_dir;

    static const Pathname _cache_tmp_dir;

    static const Pathname _cache_pubkey_dir;

    Pathname cachePath( const Pathname & sub_r ) const { return( _cache_root_dir + sub_r ); }

  private:

    Pathname cache_root_dir() const { return _cache_root_dir; }

    Pathname cache_tmp_dir() const { return cachePath( _cache_tmp_dir ); }

    Pathname cache_pubkey_dir() const { return cachePath( _cache_pubkey_dir ); }

    Pathname genSrcCacheName() const;

  private:

    struct ProductEntry {
      Pathname    _dir;
      std::string _name;
      ProductEntry( const Pathname & dir_r = "/", const std::string & name_r = std::string() ){
        _dir  = dir_r;
        _name = name_r;
      }
      bool operator<( const ProductEntry & rhs ) const {
        return( _dir.asString() < rhs._dir.asString() );
      }
    };

    typedef std::set<ProductEntry> ProductSet;

    PMError scanProductsFile( const Pathname & file_r, ProductSet & pset_r ) const;

  public:

    typedef PM::ISrcId     ISrcId;
    typedef PM::ISrcIdList ISrcIdList;

  private:

    typedef std::list<InstSrcPtr> ISrcPool;

    ISrcPool _knownSources;

    bool _want_sources_enabled;

    PMError initSrcPool( const bool autoEnable_r );

    PMError scanSrcCache( const Pathname & srccache_r );

    PMError writeNewRanks();

    ISrcPool::iterator poolHandle( const ISrcId & isrc_r );

    InstSrcPtr lookupId( const ISrcId & isrc_r ) const;

    InstSrcPtr lookupSourceByID( PM::NumericISrcID srcID_r ) const;

    ISrcId poolAdd( InstSrcPtr nsrc_r, bool rankcheck_r = true );

    PMError activateSource( const InstSrcPtr & isrc_r, bool yesno_r );

    PMError activateSource( const ISrcId & isrc_r, bool yesno_r );

    PMError intern_cacheCopyTo();

  public:

    PMError scanMedia( ISrcIdList & idlist_r, const Url & mediaurl_r );

    PMError scanMedia( ISrcId & isrc_r, const Url & mediaurl_r, const Pathname & product_dir_r );

    PMError enableSource( const ISrcId & isrc_r ) { return activateSource( isrc_r, true ); }

    PMError disableSource( const ISrcId & isrc_r ) { return activateSource( isrc_r, false ); }

    PMError refreshSource( const ISrcId & isrc_r, bool force = false );

  public:

    PMError setAutoenable( const ISrcId isrc_r, const bool yesno );

    PMError setAutorefresh( const ISrcId isrc_r, const bool yesno );

    PMError rankUp( const ISrcId isrc_r );

    PMError rankDown( const ISrcId isrc_r );

    PMError rankBehind( const ISrcId isrc_r, const ISrcId point_r );

    PMError rankBefore( const ISrcId isrc_r, const ISrcId point_r );

    PMError setNewRanks();

    PMError deleteSource( ISrcId & isrc_r );

    PMError rewriteUrl( const ISrcId isrc_r, const Url & newUrl_r );

    typedef PM::SrcState       SrcState;
    typedef PM::SrcStateVector SrcStateVector;

    SrcStateVector editGet() const;

    PMError editSet( const SrcStateVector & keep_r );

  public:

    unsigned knownSources() const { return _knownSources.size(); }

    ISrcIdList getSources( const bool enabled_only = false ) const;

    void getSources( ISrcIdList & idlist_r, const bool enabled_only = false ) const {
      idlist_r = getSources( enabled_only );
    }

    ISrcId getSourceByID( PM::NumericISrcID srcID_r ) const { return lookupSourceByID( srcID_r ); }

    void disableAllSources();

    void enableDefaultSources();

    PMError releaseMedia( const ISrcId isrc_r, bool if_removable_r = false ) const;

    PMError releaseAllMedia( bool if_removable_r = false ) const;

    void preferredLocaleChanged() const;

    PMError cacheCopyTo( const Pathname & newRoot_r );

    //
    // Temporary interface for handling install order (yast.order)
    // during installation/update.
    //

  public:

    typedef PM::InstOrder InstOrder;

  private:

    InstOrder _instOrder;

  public:

    void setInstOrder( const InstOrder & newOrder_r );

    void setDefaultInstOrder();

    const InstOrder & instOrder() const { return _instOrder; }

    ISrcIdList instOrderSources() const;

    int instOrderIndex( const ISrcId & isrc_r ) const;

    //
    // Manage gpg-pubkeys (package singning keys)
    //

  private:

    PkgPubkeyCache _pubkeyCache;

  public:

    PkgPubkeyCache & pkgPubkeyCache() { return _pubkeyCache; }

};


#endif // InstSrcManager_h

---