zypp/zypp_detail/ZYppImpl.cc

   1 /*---------------------------------------------------------------------\
   2 |                          ____ _   __ __ ___                          |
   3 |                         |__  / \ / / . \ . \                         |
   4 |                           / / \ V /|  _/  _/                         |
   5 |                          / /__ | | | | | |                           |
   6 |                         /_____||_| |_| |_|                           |
   7 |                                                                      |
   8 \---------------------------------------------------------------------*/
   9 /** \file       zypp/zypp_detail/ZYppImpl.cc
  10  *
  11 */
  12
  13 #include <iostream>
  14 #include "zypp/TmpPath.h"
  15 #include "zypp/base/Logger.h"
  16 #include "zypp/base/String.h"
  17
  18 #include "zypp/zypp_detail/ZYppImpl.h"
  19 #include "zypp/solver/detail/Helper.h"
  20 #include "zypp/target/TargetImpl.h"
  21 #include "zypp/ZYpp.h"
  22 #include "zypp/NVRAD.h"
  23 #include "zypp/DiskUsageCounter.h"
  24 #include "zypp/NameKindProxy.h"
  25 #include "zypp/Locks.h"
  26
  27 using std::endl;
  28
  29 ///////////////////////////////////////////////////////////////////
  30 namespace zypp
  31 { /////////////////////////////////////////////////////////////////
  32   ///////////////////////////////////////////////////////////////////
  33   namespace zypp_detail
  34   { /////////////////////////////////////////////////////////////////
  35
  36     ///////////////////////////////////////////////////////////////////
  37     //
  38     //  METHOD NAME : ZYppImpl::ZYppImpl
  39     //  METHOD TYPE : Constructor
  40     //
  41     ZYppImpl::ZYppImpl()
  42     : _target(0)
  43     , _resolver( new Resolver( ResPool::instance()) )
  44     {
  45       MIL << "Initializing keyring..." << std::endl;
  46       //_keyring = new KeyRing(homePath() + Pathname("/keyring/all"), homePath() + Pathname("/keyring/trusted"));
  47       _keyring = new KeyRing(tmpPath());
  48     }
  49
  50     ///////////////////////////////////////////////////////////////////
  51     //
  52     //  METHOD NAME : ZYppImpl::~ZYppImpl
  53     //  METHOD TYPE : Destructor
  54     //
  55     ZYppImpl::~ZYppImpl()
  56     {}
  57
  58     //------------------------------------------------------------------------
  59     // add/remove resolvables
  60
  61     DiskUsageCounter::MountPointSet ZYppImpl::diskUsage()
  62     {
  63       if ( ! _disk_usage )
  64       {
  65         setPartitions( DiskUsageCounter::detectMountPoints() );
  66       }
  67       return _disk_usage->disk_usage(pool());
  68     }
  69
  70     void ZYppImpl::setPartitions(const DiskUsageCounter::MountPointSet &mp)
  71     {
  72       _disk_usage.reset(new DiskUsageCounter());
  73       _disk_usage->setMountPoints(mp);
  74     }
  75
  76     DiskUsageCounter::MountPointSet ZYppImpl::getPartitions() const
  77     {
  78       if (_disk_usage)
  79         return _disk_usage->getMountPoints();
  80       else
  81         return DiskUsageCounter::detectMountPoints();
  82     }
  83
  84     //------------------------------------------------------------------------
  85     // target
  86
  87     Target_Ptr ZYppImpl::target() const
  88     {
  89       if (! _target)
  90         ZYPP_THROW(Exception("Target not initialized."));
  91       return _target;
  92      }
  93
  94     void ZYppImpl::initializeTarget(const Pathname & root)
  95     {
  96       MIL << "initTarget( " << root << endl;
  97       if (_target) {
  98           if (_target->root() == root) {
  99               MIL << "Repeated call to initializeTarget()" << endl;
 100               return;
 101           }
 102
 103           _target->unload();
 104
 105       }
 106       _target = new Target( root );
 107       _target->buildCache();
 108     }
 109
 110     void ZYppImpl::finishTarget()
 111     {
 112       if (_target)
 113           _target->unload();
 114
 115       _target = 0;
 116     }
 117
 118     //------------------------------------------------------------------------
 119     // commit
 120
 121     /** \todo Remove workflow from target, lot's of it could be done here,
 122      * and target used for transact. */
 123     ZYppCommitResult ZYppImpl::commit( const ZYppCommitPolicy & policy_r )
 124     {
 125       if ( getenv("ZYPP_TESTSUITE_FAKE_ARCH") )
 126       {
 127         ZYPP_THROW( Exception("ZYPP_TESTSUITE_FAKE_ARCH set. Commit not allowed and disabled.") );
 128       }
 129
 130       MIL << "Attempt to commit (" << policy_r << ")" << endl;
 131       if (! _target)
 132         ZYPP_THROW( Exception("Target not initialized.") );
 133
 134       ZYppCommitResult res = _target->_pimpl->commit( pool(), policy_r );
 135
 136       if (! policy_r.dryRun() ) {
 137
 138           DBG << "unloading " << sat::Pool::instance().systemRepoName() << " repo from pool" << endl;
 139
 140         _target->unload();
 141
 142         if ( policy_r.syncPoolAfterCommit() )
 143           {
 144             // reload new status from target
 145             DBG << "reloading " << sat::Pool::instance().systemRepoName() << " repo to pool" << endl;
 146             _target->load();
 147           }
 148       }
 149
 150       MIL << "Commit (" << policy_r << ") returned: "
 151           << res << endl;
 152       return res;
 153     }
 154
 155     void ZYppImpl::installSrcPackage( const SrcPackage_constPtr & srcPackage_r )
 156     {
 157       if (! _target)
 158         ZYPP_THROW( Exception("Target not initialized.") );
 159       _target->_pimpl->installSrcPackage( srcPackage_r );
 160     }
 161
 162     //------------------------------------------------------------------------
 163     // target store path
 164
 165     Pathname ZYppImpl::homePath() const
 166     { return _home_path.empty() ? Pathname("/var/lib/zypp") : _home_path; }
 167
 168     void ZYppImpl::setHomePath( const Pathname & path )
 169     { _home_path = path; }
 170
 171     Pathname ZYppImpl::tmpPath() const
 172     {
 173       static TmpDir zypp_tmp_dir( TmpPath::defaultLocation(), "zypp." );
 174       return zypp_tmp_dir.path();
 175     }
 176
 177     int ZYppImpl::applyLocks()
 178     {
 179 #warning make the /etc/zypp/locks path an option zconfig.
 180       Pathname locksrcPath( "/etc/zypp/locks" );
 181       try
 182       {
 183         Target_Ptr trg( target() );
 184         if ( trg )
 185           locksrcPath = trg->root() / locksrcPath;
 186       }
 187       catch ( ... )
 188       {
 189         // noop: Someone decided to let target() throw if the ptr is NULL ;(
 190       }
 191
 192       int num=0;
 193       PathInfo locksrc( locksrcPath );
 194       if ( locksrc.isFile() )
 195       {
 196         MIL << "Reading locks from '" << locksrcPath << "'" << endl;
 197         num = zypp::locks::readLocks( pool(), locksrcPath );
 198         MIL << num << " items locked." << endl;
 199       }
 200       else
 201       {
 202         MIL << "No file '" << locksrcPath << "' to read locks from" << endl;
 203       }
 204       return num;
 205     }
 206     /******************************************************************
 207      **
 208      ** FUNCTION NAME : operator<<
 209      ** FUNCTION TYPE : std::ostream &
 210     */
 211     std::ostream & operator<<( std::ostream & str, const ZYppImpl & obj )
 212     {
 213       return str << "ZYppImpl";
 214     }
 215
 216     /////////////////////////////////////////////////////////////////
 217   } // namespace zypp_detail
 218   ///////////////////////////////////////////////////////////////////
 219   /////////////////////////////////////////////////////////////////
 220 } // namespace zypp
 221 ///////////////////////////////////////////////////////////////////