1 /*---------------------------------------------------------------------\
3 | |__ / \ / / . \ . \ |
8 \---------------------------------------------------------------------*/
9 /** \file zypp/sat/Transaction.cc
13 #include <solv/transaction.h>
14 #include <solv/solver.h>
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/Hash.h"
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"
32 ///////////////////////////////////////////////////////////////////
34 { /////////////////////////////////////////////////////////////////
35 ///////////////////////////////////////////////////////////////////
37 { /////////////////////////////////////////////////////////////////
39 /** Transaction implementation.
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).
47 struct Transaction::Impl : protected detail::PoolMember
48 , private base::NonCopyable
50 friend std::ostream & operator<<( std::ostream & str, const Impl & obj );
53 typedef std::unordered_set<detail::IdType> set_type;
54 typedef std::unordered_map<detail::IdType,detail::IdType> map_type;
60 PostMortem( const sat::Solvable & solv_r )
61 : _ident( solv_r.ident() )
62 , _edition( solv_r.edition() )
63 , _arch( solv_r.arch() )
70 typedef std::unordered_map<detail::IdType,PostMortem> pmmap_type;
74 : _trans( ::transaction_create( nullptr ) )
75 { memset( _trans, 0, sizeof(*_trans) ); }
77 Impl( LoadFromPoolType )
78 : _watcher( myPool().serial() )
82 for ( const PoolItem & pi : ResPool::instance() )
84 if ( ! pi.status().transacts() )
86 decisionq.push( pi.isSystem() ? -pi.id() : pi.id() );
89 for ( const Solvable & solv : myPool().multiversionList() )
91 noobsq.push( SOLVER_NOOBSOLETES | SOLVER_SOLVABLE );
92 noobsq.push( solv.id() );
95 ::solver_calculate_noobsmap( myPool().getPool(), noobsq, noobsmap );
96 _trans = ::transaction_create_decisionq( myPool().getPool(), decisionq, noobsmap );
98 // NOTE: package/product buddies share the same ResStatus
99 // so we also link the buddies stepStages. This assumes
100 // only one buddy is acting during commit (package is installed,
101 // but no extra operation for the product).
102 for_( it, _trans->steps.elements, _trans->steps.elements + _trans->steps.count )
104 sat::Solvable solv( *it );
106 if ( ! solv.isKind<Package>() )
111 _linkMap[*it] = pi.buddy().id();
114 if ( solv.isSystem() )
117 if ( stepType( solv ) == TRANSACTION_ERASE )
119 _systemErase.insert( *it );
128 { ::transaction_free( _trans ); }
132 { return _watcher.isClean( myPool().serial() ); }
141 // This is hwo we could implement out own order method.
142 // As ::transaction already groups by MediaNr, we don't
143 // need it for ORDER_BY_MEDIANR.
144 ::transaction_order( _trans, SOLVER_TRANSACTION_KEEP_ORDERDATA );
145 detail::IdType chosen = 0;
150 int ret = transaction_order_add_choices( _trans, chosen, choices );
151 MIL << ret << ": " << chosen << ": " << choices << endl;
152 chosen = choices.pop_front(); // pick one out of choices
160 ::transaction_order( _trans, 0 );
167 { return( _trans->steps.count == 0 ); }
170 { return _trans->steps.count; }
172 const_iterator begin( const RW_pointer<Transaction::Impl> & self_r ) const
173 { return const_iterator( self_r, _trans->steps.elements ); }
174 iterator begin( const RW_pointer<Transaction::Impl> & self_r )
175 { return iterator( self_r, _trans->steps.elements ); }
177 const_iterator end( const RW_pointer<Transaction::Impl> & self_r ) const
178 { return const_iterator( self_r, _trans->steps.elements + _trans->steps.count ); }
179 iterator end( const RW_pointer<Transaction::Impl> & self_r )
180 { return iterator( self_r, _trans->steps.elements + _trans->steps.count ); }
182 const_iterator find(const RW_pointer<Transaction::Impl> & self_r, const sat::Solvable & solv_r ) const
183 { detail::IdType * it( _find( solv_r ) ); return it ? const_iterator( self_r, it ) : end( self_r ); }
184 iterator find(const RW_pointer<Transaction::Impl> & self_r, const sat::Solvable & solv_r )
185 { detail::IdType * it( _find( solv_r ) ); return it ? iterator( self_r, it ) : end( self_r ); }
188 int installedResult( Queue & result_r ) const
189 { return ::transaction_installedresult( _trans, result_r ); }
191 StringQueue autoInstalled() const
192 { return _autoInstalled; }
194 void autoInstalled( const StringQueue & queue_r )
195 { _autoInstalled = queue_r; }
198 StepType stepType( Solvable solv_r ) const
202 // post mortem @System solvable
203 return isIn( _systemErase, solv_r.id() ) ? TRANSACTION_ERASE : TRANSACTION_IGNORE;
206 switch( ::transaction_type( _trans, solv_r.id(), SOLVER_TRANSACTION_RPM_ONLY ) )
208 case SOLVER_TRANSACTION_ERASE: return TRANSACTION_ERASE; break;
209 case SOLVER_TRANSACTION_INSTALL: return TRANSACTION_INSTALL; break;
210 case SOLVER_TRANSACTION_MULTIINSTALL: return TRANSACTION_MULTIINSTALL; break;
212 return TRANSACTION_IGNORE;
215 StepStage stepStage( Solvable solv_r ) const
216 { return stepStage( resolve( solv_r ) ); }
218 void stepStage( Solvable solv_r, StepStage newval_r )
219 { stepStage( resolve( solv_r ), newval_r ); }
221 const PostMortem & pmdata( Solvable solv_r ) const
223 static PostMortem _none;
224 pmmap_type::const_iterator it( _pmMap.find( solv_r.id() ) );
225 return( it == _pmMap.end() ? _none : it->second );
229 detail::IdType resolve( const Solvable & solv_r ) const
231 map_type::const_iterator res( _linkMap.find( solv_r.id() ) );
232 return( res == _linkMap.end() ? solv_r.id() : res->second );
235 bool isIn( const set_type & set_r, detail::IdType sid_r ) const
236 { return( set_r.find( sid_r ) != set_r.end() ); }
238 StepStage stepStage( detail::IdType sid_r ) const
240 if ( isIn( _doneSet, sid_r ) )
242 if ( isIn( _errSet, sid_r ) )
247 void stepStage( detail::IdType sid_r, StepStage newval_r )
249 StepStage stage( stepStage( sid_r ) );
250 if ( stage != newval_r )
253 if ( stage != STEP_TODO )
255 (stage == STEP_DONE ? _doneSet : _errSet).erase( sid_r );
257 if ( newval_r != STEP_TODO )
259 (newval_r == STEP_DONE ? _doneSet : _errSet).insert( sid_r );
265 detail::IdType * _find( const sat::Solvable & solv_r ) const
267 if ( solv_r && _trans->steps.elements )
269 for_( it, _trans->steps.elements, _trans->steps.elements + _trans->steps.count )
271 if ( *it == detail::IdType(solv_r.id()) )
279 SerialNumberWatcher _watcher;
280 mutable ::Transaction * _trans;
281 DefaultIntegral<bool,false> _ordered;
285 map_type _linkMap; // buddy map to adopt buddies StepResult
286 set_type _systemErase; // @System packages to be eased (otherse are TRANSACTION_IGNORE)
287 pmmap_type _pmMap; // Post mortem data of deleted @System solvables
289 StringQueue _autoInstalled; // ident strings of all packages that would be auto-installed after the transaction is run.
292 /** Offer default Impl. */
293 static shared_ptr<Impl> nullimpl()
295 static shared_ptr<Impl> _nullimpl( new Impl );
300 /** \relates Transaction::Impl Stream output */
301 inline std::ostream & operator<<( std::ostream & str, const Transaction::Impl & obj )
303 return str << "Transaction: " << obj.size() << " (" << (obj.valid()?"valid":"INVALID") << ")";
306 ///////////////////////////////////////////////////////////////////
308 // CLASS NAME : Transaction
310 ///////////////////////////////////////////////////////////////////
312 Transaction::Transaction()
313 : _pimpl( Impl::nullimpl() )
316 Transaction::Transaction( LoadFromPoolType )
317 : _pimpl( new Impl( loadFromPool ) )
320 Transaction::~Transaction()
323 bool Transaction::valid() const
324 { return _pimpl->valid(); }
326 bool Transaction::order()
327 { return _pimpl->order(); }
329 bool Transaction::empty() const
330 { return _pimpl->empty(); }
332 size_t Transaction::size() const
333 { return _pimpl->size(); }
335 Transaction::const_iterator Transaction::begin() const
336 { return _pimpl->begin( _pimpl ); }
338 Transaction::iterator Transaction::begin()
339 { return _pimpl->begin( _pimpl ); }
341 Transaction::const_iterator Transaction::end() const
342 { return _pimpl->end( _pimpl ); }
344 Transaction::iterator Transaction::end()
345 { return _pimpl->end( _pimpl ); }
347 Transaction::const_iterator Transaction::find( const sat::Solvable & solv_r ) const
348 { return _pimpl->find( _pimpl, solv_r ); }
350 Transaction::iterator Transaction::find( const sat::Solvable & solv_r )
351 { return _pimpl->find( _pimpl, solv_r ); }
353 int Transaction::installedResult( Queue & result_r ) const
354 { return _pimpl->installedResult( result_r ); }
356 StringQueue Transaction::autoInstalled() const
357 { return _pimpl->autoInstalled(); }
359 void Transaction::autoInstalled( const StringQueue & queue_r )
360 { _pimpl->autoInstalled( queue_r ); }
362 std::ostream & operator<<( std::ostream & str, const Transaction & obj )
363 { return str << *obj._pimpl; }
365 std::ostream & dumpOn( std::ostream & str, const Transaction & obj )
367 for_( it, obj.begin(), obj.end() )
374 bool operator==( const Transaction & lhs, const Transaction & rhs )
375 { return lhs._pimpl == rhs._pimpl; }
377 ///////////////////////////////////////////////////////////////////
379 // CLASS NAME : Transaction::Step
381 ///////////////////////////////////////////////////////////////////
383 Transaction::Step::Step()
386 Transaction::StepType Transaction::Step::stepType() const
387 { return _pimpl->stepType( _solv ); }
389 Transaction::StepStage Transaction::Step::stepStage() const
390 { return _pimpl->stepStage( _solv ); }
392 void Transaction::Step::stepStage( StepStage val_r )
393 { _pimpl->stepStage( _solv, val_r ); }
395 IdString Transaction::Step::ident() const
396 { return _solv ? _solv.ident() : _pimpl->pmdata(_solv )._ident; }
398 Edition Transaction::Step::edition() const
399 { return _solv ? _solv.edition() : _pimpl->pmdata(_solv )._edition; }
401 Arch Transaction::Step::arch() const
402 { return _solv ? _solv.arch() : _pimpl->pmdata(_solv )._arch; }
404 std::ostream & operator<<( std::ostream & str, const Transaction::Step & obj )
406 str << obj.stepType() << obj.stepStage() << " ";
407 if ( obj.satSolvable() )
408 str << PoolItem( obj.satSolvable() );
410 str << '[' << obj.ident() << '-' << obj.edition() << '.' << obj.arch() << ']';
414 std::ostream & operator<<( std::ostream & str, Transaction::StepType obj )
418 #define OUTS(E,S) case Transaction::E: return str << #S; break
419 OUTS( TRANSACTION_IGNORE, [ ] );
420 OUTS( TRANSACTION_ERASE, [-] );
421 OUTS( TRANSACTION_INSTALL, [+] );
422 OUTS( TRANSACTION_MULTIINSTALL, [M] );
428 std::ostream & operator<<( std::ostream & str, Transaction::StepStage obj )
432 #define OUTS(E,S) case Transaction::E: return str << #S; break
433 OUTS( STEP_TODO, [__] );
434 OUTS( STEP_DONE, [OK] );
435 OUTS( STEP_ERROR, [**] );
438 return str << "[??]";
440 ///////////////////////////////////////////////////////////////////
442 { /////////////////////////////////////////////////////////////////
443 ///////////////////////////////////////////////////////////////////
445 // CLASS NAME : Transaction::const_iterator/iterator
447 ///////////////////////////////////////////////////////////////////
449 Transaction_const_iterator::Transaction_const_iterator()
450 : Transaction_const_iterator::iterator_adaptor_( 0 )
453 Transaction_const_iterator::Transaction_const_iterator( const Transaction_iterator & iter_r )
454 : Transaction_const_iterator::iterator_adaptor_( iter_r.base() )
455 , _pimpl( iter_r._pimpl )
458 Transaction_iterator::Transaction_iterator()
459 : Transaction_iterator::iterator_adaptor_( 0 )
462 /////////////////////////////////////////////////////////////////
463 } // namespace detail
464 ///////////////////////////////////////////////////////////////////
465 /////////////////////////////////////////////////////////////////
467 ///////////////////////////////////////////////////////////////////
468 /////////////////////////////////////////////////////////////////
470 ///////////////////////////////////////////////////////////////////