ZYppCommitPolicy.cc

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#include <iostream>
 
#include <zypp-core/base/String.h>
#include <zypp-core/base/StringV.h>
 
#include <zypp/ZConfig.h>
#include <zypp/ZYppCommitPolicy.h>
#include <zypp-core/base/LogControl.h>
#include <zypp-core/TriBool.h>
 
namespace zypp
{ 
 
 
  bool singleTransInEnv ()
  {
    static TriBool singleTrans = indeterminate;
    if ( indeterminate(singleTrans) ) {
      const char *val = ::getenv("ZYPP_SINGLE_RPMTRANS");
      if ( val && std::string_view( val ) == "1"  )
        singleTrans = true;
      else
        singleTrans = false;
    }
    // for some reason some compilers do not accept the implicit conversion to bool here.
    return bool( singleTrans );
  }
 
  //
  //    CLASS NAME : ZYppCommitPolicy::Impl
  //
 
  class ZYppCommitPolicy::Impl
  {
    public:
      Impl()
      : _restrictToMedia        ( 0 )
      , _downloadMode           ( ZConfig::instance().commit_downloadMode() )
      , _rpmInstFlags           ( ZConfig::instance().rpmInstallFlags() )
      , _syncPoolAfterCommit    ( true )
      , _singleTransMode        ( singleTransInEnv() )
      {}
 
    public:
      unsigned                  _restrictToMedia;
      DownloadMode              _downloadMode;
      target::rpm::RpmInstFlags _rpmInstFlags;
      bool                      _syncPoolAfterCommit;
      bool                      _singleTransMode; //< run everything in one big rpm transaction
 
    private:
      friend Impl * rwcowClone<Impl>( const Impl * rhs );
      Impl * clone() const { return new Impl( *this ); }
  };
 
  //
  //    CLASS NAME : ZYppCommitPolicy
  //
 
  ZYppCommitPolicy::ZYppCommitPolicy()
  : _pimpl( new Impl )
  {}
 
 
  ZYppCommitPolicy & ZYppCommitPolicy::restrictToMedia( unsigned mediaNr_r )
  { _pimpl->_restrictToMedia = ( mediaNr_r == 1 ) ? 1 : 0; return *this; }
 
  unsigned ZYppCommitPolicy::restrictToMedia() const
  { return _pimpl->_restrictToMedia; }
 
 
  ZYppCommitPolicy & ZYppCommitPolicy::dryRun( bool yesNo_r )
  {  _pimpl->_rpmInstFlags.setFlag( target::rpm::RPMINST_TEST, yesNo_r ); return *this; }
 
  bool ZYppCommitPolicy::dryRun() const
  { return _pimpl->_rpmInstFlags.testFlag( target::rpm::RPMINST_TEST );}
 
  ZYppCommitPolicy & ZYppCommitPolicy::downloadMode( DownloadMode val_r )
  {
    if ( singleTransModeEnabled() && val_r == DownloadAsNeeded ) {
      DBG << val_r << " is not compatible with singleTransMode, falling back to " << DownloadInAdvance << std::endl;
      _pimpl->_downloadMode = DownloadInAdvance;
    }
    _pimpl->_downloadMode = val_r; return *this;
  }
 
  DownloadMode ZYppCommitPolicy::downloadMode() const
  {
    if ( singleTransModeEnabled() && _pimpl->_downloadMode == DownloadAsNeeded ) {
      DBG << _pimpl->_downloadMode << " is not compatible with singleTransMode, falling back to " << DownloadInAdvance << std::endl;
      return DownloadInAdvance;
    }
    return _pimpl->_downloadMode;
  }
 
  ZYppCommitPolicy &  ZYppCommitPolicy::rpmInstFlags( target::rpm::RpmInstFlags newFlags_r )
  { _pimpl->_rpmInstFlags = newFlags_r; return *this; }
 
  ZYppCommitPolicy & ZYppCommitPolicy::rpmNoSignature( bool yesNo_r )
  { _pimpl->_rpmInstFlags.setFlag( target::rpm::RPMINST_NOSIGNATURE, yesNo_r ); return *this; }
 
  ZYppCommitPolicy & ZYppCommitPolicy::rpmExcludeDocs( bool yesNo_r )
  { _pimpl->_rpmInstFlags.setFlag( target::rpm::RPMINST_EXCLUDEDOCS, yesNo_r ); return *this; }
 
  target::rpm::RpmInstFlags ZYppCommitPolicy::rpmInstFlags() const
  { return _pimpl->_rpmInstFlags; }
 
  bool ZYppCommitPolicy::rpmNoSignature() const
  { return _pimpl->_rpmInstFlags.testFlag( target::rpm::RPMINST_NOSIGNATURE ); }
 
  bool ZYppCommitPolicy::rpmExcludeDocs() const
  { return _pimpl->_rpmInstFlags.testFlag( target::rpm::RPMINST_EXCLUDEDOCS ); }
 
  ZYppCommitPolicy &ZYppCommitPolicy::allowDowngrade(bool yesNo_r)
  { _pimpl->_rpmInstFlags.setFlag( target::rpm::RPMINST_ALLOWDOWNGRADE, yesNo_r ); return *this; }
 
  bool ZYppCommitPolicy::allowDowngrade() const
  { return _pimpl->_rpmInstFlags.testFlag( target::rpm::RPMINST_ALLOWDOWNGRADE ); }
 
  ZYppCommitPolicy &ZYppCommitPolicy::replaceFiles( bool yesNo_r )
  { _pimpl->_rpmInstFlags.setFlag( target::rpm::RPMINST_REPLACEFILES, yesNo_r ); return *this; }
 
  bool ZYppCommitPolicy::replaceFiles( ) const
  { return _pimpl->_rpmInstFlags.testFlag( target::rpm::RPMINST_REPLACEFILES ); }
 
  ZYppCommitPolicy & ZYppCommitPolicy::syncPoolAfterCommit( bool yesNo_r )
  { _pimpl->_syncPoolAfterCommit = yesNo_r; return *this; }
 
  bool ZYppCommitPolicy::syncPoolAfterCommit() const
  { return _pimpl->_syncPoolAfterCommit; }
 
  bool ZYppCommitPolicy::singleTransModeEnabled() const
  { return _pimpl->_singleTransMode; }
 
  std::ostream & operator<<( std::ostream & str, const ZYppCommitPolicy & obj )
  {
    str << "CommitPolicy(";
    if ( obj.restrictToMedia() )
      str << " restrictToMedia:" << obj.restrictToMedia();
    if ( obj.dryRun() )
      str << " dryRun";
    str << " " << obj.downloadMode();
    if ( obj.syncPoolAfterCommit() )
      str << " syncPoolAfterCommit";
    if ( obj.rpmInstFlags() )
      str << " rpmInstFlags{" << str::hexstring(obj.rpmInstFlags()) << "}";
    return str << " )";
  }
 
} // namespace zypp