zypp/sat/Transaction.cc

   1 /*---------------------------------------------------------------------\
   2 |                          ____ _   __ __ ___                          |
   3 |                         |__  / \ / / . \ . \                         |
   4 |                           / / \ V /|  _/  _/                         |
   5 |                          / /__ | | | | | |                           |
   6 |                         /_____||_| |_| |_|                           |
   7 |                                                                      |
   8 \---------------------------------------------------------------------*/
   9 /** \file       zypp/sat/Transaction.cc
  10  */
  11 extern "C"
  12 {
  13 #include <solv/transaction.h>
  14 #include <solv/solver.h>
  15 }
  16 #include <iostream>
  17 #include "zypp/base/LogTools.h"
  18 #include "zypp/base/SerialNumber.h"
  19 #include "zypp/base/DefaultIntegral.h"
  20 #include "zypp/base/NonCopyable.h"
  21 #include "zypp/base/Tr1hash.h"
  22
  23 #include "zypp/sat/detail/PoolImpl.h"
  24 #include "zypp/sat/Transaction.h"
  25 #include "zypp/sat/Solvable.h"
  26 #include "zypp/sat/Queue.h"
  27 #include "zypp/sat/Map.h"
  28 #include "zypp/ResPool.h"
  29
  30 using std::endl;
  31
  32 ///////////////////////////////////////////////////////////////////
  33 namespace zypp
  34 { /////////////////////////////////////////////////////////////////
  35   ///////////////////////////////////////////////////////////////////
  36   namespace sat
  37   { /////////////////////////////////////////////////////////////////
  38
  39     /** Transaction implementation.
  40      *
  41      * \NOTE After commit the @System repo is reloaded. This invalidates
  42      * the ids off all installed items in the transaction, including their
  43      * stepType. Thats why some information (stepType, NVRA) is be stored
  44      * for post mortem access (i.e. tell after commit which NVRA were deleted).
  45      *
  46      */
  47     struct Transaction::Impl : protected detail::PoolMember
  48                              , private base::NonCopyable
  49     {
  50       friend std::ostream & operator<<( std::ostream & str, const Impl & obj );
  51
  52       public:
  53         typedef std::tr1::unordered_set<detail::IdType> set_type;
  54         typedef std::tr1::unordered_map<detail::IdType,detail::IdType> map_type;
  55
  56         struct PostMortem
  57         {
  58           PostMortem()
  59           {}
  60           PostMortem( const sat::Solvable & solv_r )
  61             : _ident( solv_r.ident() )
  62             , _edition( solv_r.edition() )
  63             , _arch( solv_r.arch() )
  64           {}
  65
  66           IdString _ident;
  67           Edition  _edition;
  68           Arch     _arch;
  69         };
  70         typedef std::tr1::unordered_map<detail::IdType,PostMortem> pmmap_type;
  71
  72       public:
  73         Impl()
  74           : _trans( ::transaction_create( nullptr ) )
  75         { memset( _trans, 0, sizeof(_trans) ); }
  76
  77         Impl( LoadFromPoolType )
  78           : _watcher( myPool().serial() )
  79           , _trans( nullptr )
  80         {
  81           Queue decisionq;
  82           for_( it, ResPool::instance().begin(), ResPool::instance().end() )
  83           {
  84             if ( ! (*it).status().transacts() )
  85               continue;
  86             sat::Solvable solv( (*it).satSolvable() );
  87             decisionq.push( solv.isSystem() ? -solv.id() : solv.id() );
  88           }
  89           Queue noobsq;
  90           for_( it, sat::Pool::instance().multiversionBegin(), sat::Pool::instance().multiversionEnd() )
  91           {
  92             noobsq.push( SOLVER_NOOBSOLETES | SOLVER_SOLVABLE_NAME );
  93             noobsq.push( it->id() );
  94           }
  95           Map noobsmap;
  96           ::solver_calculate_noobsmap( myPool().getPool(), noobsq, noobsmap );
  97           _trans = ::transaction_create_decisionq( myPool().getPool(), decisionq, noobsmap );
  98
  99           // NOTE: package/product buddies share the same ResStatus
 100           // so we also link the buddies stepStages. This assumes
 101           // only one buddy is acting during commit (package is installed,
 102           // but no extra operation for the product).
 103           for_( it, _trans->steps.elements, _trans->steps.elements + _trans->steps.count )
 104           {
 105             sat::Solvable solv( *it );
 106             // buddy list:
 107             if ( ! solv.isKind<Package>() )
 108             {
 109               PoolItem pi( solv );
 110               if ( pi.buddy() )
 111               {
 112                 _linkMap[*it] = pi.buddy().id();
 113               }
 114             }
 115             if ( solv.isSystem() )
 116             {
 117               // to delete list:
 118               if ( stepType( solv ) == TRANSACTION_ERASE )
 119               {
 120                 _systemErase.insert( *it );
 121               }
 122               // post mortem data
 123               _pmMap[*it] = solv;
 124             }
 125           }
 126         }
 127
 128         ~Impl()
 129         { ::transaction_free( _trans ); }
 130
 131       public:
 132         bool valid() const
 133         { return _watcher.isClean( myPool().serial() ); }
 134
 135         bool order()
 136         {
 137           if ( ! valid() )
 138             return false;
 139           if ( empty() )
 140             return true;
 141 #if 0
 142           // This is hwo we could implement out own order method.
 143           // As ::transaction already groups by MediaNr, we don't
 144           // need it for ORDER_BY_MEDIANR.
 145           ::transaction_order( _trans, SOLVER_TRANSACTION_KEEP_ORDERDATA );
 146           detail::IdType chosen = 0;
 147           Queue choices;
 148
 149           while ( true )
 150           {
 151             int ret = transaction_order_add_choices( _trans, chosen, choices );
 152             MIL << ret << ": " << chosen << ": " << choices << endl;
 153             chosen = choices.pop_front(); // pick one out of choices
 154             if ( ! chosen )
 155               break;
 156           }
 157           return true;
 158 #endif
 159           if ( !_ordered )
 160           {
 161             ::transaction_order( _trans, 0 );
 162             _ordered = true;
 163           }
 164           return true;
 165         }
 166
 167         bool empty() const
 168         { return( _trans->steps.count == 0 ); }
 169
 170         size_t size() const
 171         { return _trans->steps.count; }
 172
 173         const_iterator begin( const RW_pointer<Transaction::Impl> & self_r ) const
 174         { return const_iterator( self_r, _trans->steps.elements ); }
 175         iterator begin( const RW_pointer<Transaction::Impl> & self_r )
 176         { return iterator( self_r, _trans->steps.elements ); }
 177
 178         const_iterator end( const RW_pointer<Transaction::Impl> & self_r ) const
 179         { return const_iterator( self_r, _trans->steps.elements + _trans->steps.count ); }
 180         iterator end( const RW_pointer<Transaction::Impl> & self_r )
 181         { return iterator( self_r, _trans->steps.elements + _trans->steps.count ); }
 182
 183         const_iterator find(const RW_pointer<Transaction::Impl> & self_r, const sat::Solvable & solv_r ) const
 184         { detail::IdType * it( _find( solv_r ) ); return it ? const_iterator( self_r, it ) : end( self_r ); }
 185         iterator find(const RW_pointer<Transaction::Impl> & self_r, const sat::Solvable & solv_r )
 186         { detail::IdType * it( _find( solv_r ) ); return it ? iterator( self_r, it ) : end( self_r ); }
 187
 188       public:
 189         int installedResult( Queue & result_r ) const
 190         { return ::transaction_installedresult( _trans, result_r ); }
 191
 192       public:
 193         StepType stepType( Solvable solv_r ) const
 194         {
 195           if ( ! solv_r )
 196           {
 197             // post mortem @System solvable
 198             return isIn( _systemErase, solv_r.id() ) ? TRANSACTION_ERASE : TRANSACTION_IGNORE;
 199           }
 200
 201           switch( ::transaction_type( _trans, solv_r.id(), SOLVER_TRANSACTION_RPM_ONLY ) )
 202           {
 203             case SOLVER_TRANSACTION_ERASE: return TRANSACTION_ERASE; break;
 204             case SOLVER_TRANSACTION_INSTALL: return TRANSACTION_INSTALL; break;
 205             case SOLVER_TRANSACTION_MULTIINSTALL: return TRANSACTION_MULTIINSTALL; break;
 206           }
 207           return TRANSACTION_IGNORE;
 208         }
 209
 210         StepStage stepStage( Solvable solv_r ) const
 211         { return stepStage( resolve( solv_r ) ); }
 212
 213         void stepStage( Solvable solv_r, StepStage newval_r )
 214         { stepStage( resolve( solv_r ), newval_r ); }
 215
 216         const PostMortem & pmdata( Solvable solv_r ) const
 217         {
 218           static PostMortem _none;
 219           pmmap_type::const_iterator it( _pmMap.find( solv_r.id() ) );
 220           return( it == _pmMap.end() ? _none : it->second );
 221         }
 222
 223       private:
 224         detail::IdType resolve( const Solvable & solv_r ) const
 225         {
 226           map_type::const_iterator res( _linkMap.find( solv_r.id() ) );
 227           return( res == _linkMap.end() ? solv_r.id() : res->second );
 228         }
 229
 230         bool isIn( const set_type & set_r, detail::IdType sid_r ) const
 231         { return( set_r.find( sid_r ) != set_r.end() ); }
 232
 233         StepStage stepStage( detail::IdType sid_r ) const
 234         {
 235           if ( isIn( _doneSet, sid_r ) )
 236             return STEP_DONE;
 237           if ( isIn( _errSet, sid_r ) )
 238             return STEP_ERROR;
 239           return STEP_TODO;
 240         }
 241
 242         void stepStage( detail::IdType sid_r, StepStage newval_r )
 243         {
 244           StepStage stage( stepStage( sid_r ) );
 245           if ( stage != newval_r )
 246           {
 247             // reset old stage
 248             if ( stage != STEP_TODO )
 249             {
 250               (stage == STEP_DONE ? _doneSet : _errSet).erase( sid_r );
 251             }
 252             if ( newval_r != STEP_TODO )
 253             {
 254               (newval_r == STEP_DONE ? _doneSet : _errSet).insert( sid_r );
 255             }
 256           }
 257         }
 258
 259       private:
 260         detail::IdType * _find( const sat::Solvable & solv_r ) const
 261         {
 262           if ( solv_r && _trans->steps.elements )
 263           {
 264             for_( it, _trans->steps.elements, _trans->steps.elements + _trans->steps.count )
 265             {
 266               if ( *it == detail::IdType(solv_r.id()) )
 267                 return it;
 268             }
 269           }
 270           return 0;
 271         }
 272
 273      private:
 274         SerialNumberWatcher _watcher;
 275         mutable ::Transaction * _trans;
 276         DefaultIntegral<bool,false> _ordered;
 277         //
 278         set_type        _doneSet;
 279         set_type        _errSet;
 280         map_type        _linkMap;       // buddy map to adopt buddies StepResult
 281         set_type        _systemErase;   // @System packages to be eased (otherse are TRANSACTION_IGNORE)
 282         pmmap_type      _pmMap;         // Post mortem data of deleted @System solvables
 283
 284       public:
 285         /** Offer default Impl. */
 286         static shared_ptr<Impl> nullimpl()
 287         {
 288           static shared_ptr<Impl> _nullimpl( new Impl );
 289           return _nullimpl;
 290         }
 291     };
 292
 293     /** \relates Transaction::Impl Stream output */
 294     inline std::ostream & operator<<( std::ostream & str, const Transaction::Impl & obj )
 295     {
 296       return str << "Transaction: " << obj.size() << " (" << (obj.valid()?"valid":"INVALID") << ")";
 297     }
 298
 299     ///////////////////////////////////////////////////////////////////
 300     //
 301     //  CLASS NAME : Transaction
 302     //
 303     ///////////////////////////////////////////////////////////////////
 304
 305     Transaction::Transaction()
 306       : _pimpl( Impl::nullimpl() )
 307     {}
 308
 309     Transaction::Transaction( LoadFromPoolType )
 310       : _pimpl( new Impl( loadFromPool ) )
 311     {}
 312
 313     Transaction::~Transaction()
 314     {}
 315
 316     bool Transaction::valid() const
 317     { return _pimpl->valid(); }
 318
 319     bool Transaction::order()
 320     { return _pimpl->order(); }
 321
 322     bool Transaction::empty() const
 323     { return _pimpl->empty(); }
 324
 325     size_t Transaction::size() const
 326     { return _pimpl->size(); }
 327
 328     Transaction::const_iterator Transaction::begin() const
 329     { return _pimpl->begin( _pimpl ); }
 330
 331     Transaction::iterator Transaction::begin()
 332     { return _pimpl->begin( _pimpl ); }
 333
 334     Transaction::const_iterator Transaction::end() const
 335     { return _pimpl->end( _pimpl ); }
 336
 337     Transaction::iterator Transaction::end()
 338     { return _pimpl->end( _pimpl ); }
 339
 340     Transaction::const_iterator Transaction::find( const sat::Solvable & solv_r ) const
 341     { return _pimpl->find( _pimpl, solv_r ); }
 342
 343     Transaction::iterator Transaction::find( const sat::Solvable & solv_r )
 344     { return _pimpl->find( _pimpl, solv_r ); }
 345
 346     int Transaction::installedResult( Queue & result_r ) const
 347     { return _pimpl->installedResult( result_r ); }
 348
 349
 350     std::ostream & operator<<( std::ostream & str, const Transaction & obj )
 351     { return str << *obj._pimpl; }
 352
 353     std::ostream & dumpOn( std::ostream & str, const Transaction & obj )
 354     {
 355       for_( it, obj.begin(), obj.end() )
 356       {
 357         str << *it << endl;
 358       }
 359       return str;
 360     }
 361
 362     bool operator==( const Transaction & lhs, const Transaction & rhs )
 363     { return lhs._pimpl == rhs._pimpl; }
 364
 365     ///////////////////////////////////////////////////////////////////
 366     //
 367     //  CLASS NAME : Transaction::Step
 368     //
 369     ///////////////////////////////////////////////////////////////////
 370
 371     Transaction::Step::Step()
 372     {}
 373
 374     Transaction::StepType Transaction::Step::stepType() const
 375     { return _pimpl->stepType( _solv ); }
 376
 377     Transaction::StepStage Transaction::Step::stepStage() const
 378     { return _pimpl->stepStage( _solv ); }
 379
 380     void Transaction::Step::stepStage( StepStage val_r )
 381     { _pimpl->stepStage( _solv, val_r ); }
 382
 383     IdString Transaction::Step::ident() const
 384     { return _solv ? _solv.ident() : _pimpl->pmdata(_solv )._ident; }
 385
 386     Edition Transaction::Step::edition() const
 387     { return _solv ? _solv.edition() : _pimpl->pmdata(_solv )._edition; }
 388
 389     Arch Transaction::Step::arch() const
 390     { return _solv ? _solv.arch() : _pimpl->pmdata(_solv )._arch; }
 391
 392     std::ostream & operator<<( std::ostream & str, const Transaction::Step & obj )
 393     {
 394       str << obj.stepType() << obj.stepStage() << " ";
 395       if ( obj.satSolvable() )
 396         str << PoolItem( obj.satSolvable() );
 397       else
 398         str << '[' << obj.ident() << '-' << obj.edition() << '.' << obj.arch() << ']';
 399       return str;
 400     }
 401
 402     std::ostream & operator<<( std::ostream & str, Transaction::StepType obj )
 403     {
 404       switch ( obj )
 405       {
 406         #define OUTS(E,S) case Transaction::E: return str << #S; break
 407         OUTS( TRANSACTION_IGNORE,       [ ] );
 408         OUTS( TRANSACTION_ERASE,        [-] );
 409         OUTS( TRANSACTION_INSTALL,      [+] );
 410         OUTS( TRANSACTION_MULTIINSTALL, [M] );
 411         #undef OUTS
 412       }
 413       return str << "[?]";
 414     }
 415
 416     std::ostream & operator<<( std::ostream & str, Transaction::StepStage obj )
 417     {
 418       switch ( obj )
 419       {
 420         #define OUTS(E,S) case Transaction::E: return str << #S; break
 421         OUTS( STEP_TODO,        [__] );
 422         OUTS( STEP_DONE,        [OK] );
 423         OUTS( STEP_ERROR,       [**] );
 424         #undef OUTS
 425       }
 426       return str << "[??]";
 427     }
 428     ///////////////////////////////////////////////////////////////////
 429     namespace detail
 430     { /////////////////////////////////////////////////////////////////
 431       ///////////////////////////////////////////////////////////////////
 432       //
 433       //        CLASS NAME : Transaction::const_iterator/iterator
 434       //
 435       ///////////////////////////////////////////////////////////////////
 436
 437       Transaction_const_iterator::Transaction_const_iterator()
 438       : Transaction_const_iterator::iterator_adaptor_( 0 )
 439       {}
 440
 441       Transaction_const_iterator::Transaction_const_iterator( const Transaction_iterator & iter_r )
 442       : Transaction_const_iterator::iterator_adaptor_( iter_r.base() )
 443       , _pimpl( iter_r._pimpl )
 444       {}
 445
 446       Transaction_iterator::Transaction_iterator()
 447       : Transaction_iterator::iterator_adaptor_( 0 )
 448       {}
 449
 450       /////////////////////////////////////////////////////////////////
 451     } // namespace detail
 452     ///////////////////////////////////////////////////////////////////
 453     /////////////////////////////////////////////////////////////////
 454   } // namespace sat
 455   ///////////////////////////////////////////////////////////////////
 456   /////////////////////////////////////////////////////////////////
 457 } // namespace zypp
 458 ///////////////////////////////////////////////////////////////////