Cleanup unused /var/lib/zypp/cache in migrate_sources
[platform/upstream/libzypp.git] / devel / devel.ma / NewPool.cc
1 #include "Tools.h"
2
3 #include <zypp/base/PtrTypes.h>
4 #include <zypp/base/Exception.h>
5 #include <zypp/base/Gettext.h>
6 #include <zypp/base/LogTools.h>
7 #include <zypp/base/Debug.h>
8 #include <zypp/base/Functional.h>
9 #include <zypp/base/ProvideNumericId.h>
10 #include <zypp/AutoDispose.h>
11
12 #include "zypp/ResPoolProxy.h"
13
14 #include "zypp/ZYppCallbacks.h"
15 #include "zypp/NVRAD.h"
16 #include "zypp/ResPool.h"
17 #include "zypp/ResFilters.h"
18 #include "zypp/CapFilters.h"
19 #include "zypp/ResObjects.h"
20 #include "zypp/Digest.h"
21 #include "zypp/PackageKeyword.h"
22 #include "zypp/ManagedFile.h"
23 #include "zypp/NameKindProxy.h"
24 #include "zypp/pool/GetResolvablesToInsDel.h"
25
26 #include "zypp/RepoManager.h"
27 #include "zypp/RepoInfo.h"
28
29 #include "zypp/repo/PackageProvider.h"
30
31 #include "zypp/ui/PatchContents.h"
32 #include "zypp/ResPoolProxy.h"
33
34 #include "zypp/sat/Pool.h"
35 #include "zypp/sat/Repo.h"
36 #include "zypp/sat/Solvable.h"
37 #include "zypp/sat/detail/PoolMember.h"
38 #include "zypp/sat/detail/PoolImpl.h"
39
40 #include <zypp/base/GzStream.h>
41
42 #include <boost/mpl/int.hpp>
43
44 using namespace std;
45 using namespace zypp;
46 using namespace zypp::functor;
47 using namespace zypp::ui;
48
49 ///////////////////////////////////////////////////////////////////
50
51 static const Pathname sysRoot( getenv("SYSROOT") ? getenv("SYSROOT") : "/Local/ROOT" );
52
53 ///////////////////////////////////////////////////////////////////
54 ///////////////////////////////////////////////////////////////////
55 namespace zypp
56 { /////////////////////////////////////////////////////////////////
57
58 bool queryInstalledEditionHelper( const std::string & name_r,
59                                   const Edition &     ed_r,
60                                   const Arch &        arch_r )
61 {
62   if ( ed_r == Edition::noedition )
63     return true;
64   if ( name_r == "kernel-default" && ed_r == Edition("2.6.22.5-10") )
65     return true;
66   if ( name_r == "update-test-affects-package-manager" && ed_r == Edition("1.1-6") )
67     return true;
68
69   return false;
70 }
71
72
73 ManagedFile repoProvidePackage( const PoolItem & pi )
74 {
75   ResPool _pool( getZYpp()->pool() );
76   repo::RepoMediaAccess _access;
77
78   // Redirect PackageProvider queries for installed editions
79   // (in case of patch/delta rpm processing) to rpmDb.
80   repo::PackageProviderPolicy packageProviderPolicy;
81   packageProviderPolicy.queryInstalledCB( queryInstalledEditionHelper );
82
83   Package::constPtr p = asKind<Package>(pi.resolvable());
84
85   // Build a repository list for repos
86   // contributing to the pool
87   repo::DeltaCandidates deltas( repo::makeDeltaCandidates( _pool.knownRepositoriesBegin(),
88                                                            _pool.knownRepositoriesEnd() ) );
89   repo::PackageProvider pkgProvider( _access, p, deltas, packageProviderPolicy );
90   return pkgProvider.providePackage();
91 }
92
93   /////////////////////////////////////////////////////////////////
94 } // namespace zypp
95 ///////////////////////////////////////////////////////////////////
96 ///////////////////////////////////////////////////////////////////
97
98 namespace zypp
99 {
100   template <class _LIterator, class _RIterator, class _Function>
101       inline int invokeOnEach( _LIterator lbegin_r, _LIterator lend_r,
102                                _RIterator rbegin_r, _RIterator rend_r,
103                                _Function fnc_r )
104       {
105         int cnt = 0;
106         for ( _LIterator lit = lbegin_r; lit != lend_r; ++lit )
107         {
108           for ( _RIterator rit = rbegin_r; rit != rend_r; ++rit )
109           {
110             ++cnt;
111             if ( ! fnc_r( *lit, *rit ) )
112               return -cnt;
113           }
114         }
115         return cnt;
116       }
117 }
118
119
120 void dbgDu( Selectable::Ptr sel )
121 {
122   if ( sel->installedPoolItem() )
123   {
124     DBG << "i: " << sel->installedPoolItem() << endl
125         << sel->installedPoolItem()->diskusage() << endl;
126   }
127   if ( sel->candidatePoolItem() )
128   {
129     DBG << "c: " << sel->candidatePoolItem() << endl
130         << sel->candidatePoolItem()->diskusage() << endl;
131   }
132   INT << sel << endl
133       << getZYpp()->diskUsage() << endl;
134 }
135
136 ///////////////////////////////////////////////////////////////////
137
138 struct Xprint
139 {
140   bool operator()( const PoolItem & obj_r )
141   {
142     //MIL << obj_r << endl;
143     //DBG << " -> " << obj_r->satSolvable() << endl;
144
145     return true;
146   }
147
148   bool operator()( const sat::Solvable & obj_r )
149   {
150     //dumpOn( MIL, obj_r ) << endl;
151     return true;
152   }
153 };
154
155 ///////////////////////////////////////////////////////////////////
156 struct SetTransactValue
157 {
158   SetTransactValue( ResStatus::TransactValue newVal_r, ResStatus::TransactByValue causer_r )
159   : _newVal( newVal_r )
160   , _causer( causer_r )
161   {}
162
163   ResStatus::TransactValue   _newVal;
164   ResStatus::TransactByValue _causer;
165
166   bool operator()( const PoolItem & pi ) const
167   {
168     bool ret = pi.status().setTransactValue( _newVal, _causer );
169     if ( ! ret )
170       ERR << _newVal <<  _causer << " " << pi << endl;
171     return ret;
172   }
173 };
174
175 struct StatusReset : public SetTransactValue
176 {
177   StatusReset()
178   : SetTransactValue( ResStatus::KEEP_STATE, ResStatus::USER )
179   {}
180 };
181
182 struct StatusInstall : public SetTransactValue
183 {
184   StatusInstall()
185   : SetTransactValue( ResStatus::TRANSACT, ResStatus::USER )
186   {}
187 };
188
189 inline bool g( const NameKindProxy & nkp, Arch arch = Arch() )
190 {
191   if ( nkp.availableEmpty() )
192   {
193     ERR << "No Item to select: " << nkp << endl;
194     return false;
195     ZYPP_THROW( Exception("No Item to select") );
196   }
197
198   if ( arch != Arch() )
199   {
200     typeof( nkp.availableBegin() ) it =  nkp.availableBegin();
201     for ( ; it != nkp.availableEnd(); ++it )
202     {
203       if ( (*it)->arch() == arch )
204         return (*it).status().setTransact( true, ResStatus::USER );
205     }
206   }
207
208   return nkp.availableBegin()->status().setTransact( true, ResStatus::USER );
209 }
210
211 ///////////////////////////////////////////////////////////////////
212
213 bool solve()
214 {
215   bool rres = false;
216   {
217     //zypp::base::LogControl::TmpLineWriter shutUp;
218     rres = getZYpp()->resolver()->resolvePool();
219   }
220   if ( ! rres )
221   {
222     ERR << "resolve " << rres << endl;
223     return false;
224   }
225   MIL << "resolve " << rres << endl;
226   return true;
227 }
228
229 bool install()
230 {
231   SEC << getZYpp()->commit( ZYppCommitPolicy() ) << endl;
232   return true;
233 }
234
235 ///////////////////////////////////////////////////////////////////
236
237 struct ConvertDbReceive : public callback::ReceiveReport<target::ScriptResolvableReport>
238 {
239   virtual void start( const Resolvable::constPtr & script_r,
240                       const Pathname & path_r,
241                       Task task_r )
242   {
243     SEC << __FUNCTION__ << endl
244     << "  " << script_r << endl
245     << "  " << path_r   << endl
246     << "  " << task_r   << endl;
247   }
248
249   virtual bool progress( Notify notify_r, const std::string & text_r )
250   {
251     SEC << __FUNCTION__ << endl
252     << "  " << notify_r << endl
253     << "  " << text_r   << endl;
254     return true;
255   }
256
257   virtual void problem( const std::string & description_r )
258   {
259     SEC << __FUNCTION__ << endl
260     << "  " << description_r << endl;
261   }
262
263   virtual void finish()
264   {
265     SEC << __FUNCTION__ << endl;
266   }
267
268 };
269 ///////////////////////////////////////////////////////////////////
270
271 struct DigestReceive : public callback::ReceiveReport<DigestReport>
272 {
273   DigestReceive()
274   {
275     connect();
276   }
277
278   virtual bool askUserToAcceptNoDigest( const zypp::Pathname &file )
279   {
280     USR << endl;
281     return false;
282   }
283   virtual bool askUserToAccepUnknownDigest( const Pathname &file, const std::string &name )
284   {
285     USR << endl;
286     return false;
287   }
288   virtual bool askUserToAcceptWrongDigest( const Pathname &file, const std::string &requested, const std::string &found )
289   {
290     USR << "fle " << PathInfo(file) << endl;
291     USR << "req " << requested << endl;
292     USR << "fnd " << found << endl;
293     return false;
294   }
295 };
296
297 struct KeyRingSignalsReceive : public callback::ReceiveReport<KeyRingSignals>
298 {
299   KeyRingSignalsReceive()
300   {
301     connect();
302   }
303   virtual void trustedKeyAdded( const PublicKey &/*key*/ )
304   {
305     USR << endl;
306   }
307   virtual void trustedKeyRemoved( const PublicKey &/*key*/ )
308   {
309     USR << endl;
310   }
311 };
312
313 ///////////////////////////////////////////////////////////////////
314
315 struct MediaChangeReceive : public callback::ReceiveReport<media::MediaChangeReport>
316 {
317   virtual Action requestMedia( Url & source
318                                , unsigned mediumNr
319                                , Error error
320                                , const std::string & description )
321   {
322     SEC << __FUNCTION__ << endl
323     << "  " << source << endl
324     << "  " << mediumNr << endl
325     << "  " << error << endl
326     << "  " << description << endl;
327     return IGNORE;
328   }
329 };
330
331 ///////////////////////////////////////////////////////////////////
332
333 namespace container
334 {
335   template<class _Tp>
336     bool isIn( const std::set<_Tp> & cont, const typename std::set<_Tp>::value_type & val )
337     { return cont.find( val ) != cont.end(); }
338 }
339 ///////////////////////////////////////////////////////////////////
340
341 void itCmp( const sat::Pool::SolvableIterator & l, const sat::Pool::SolvableIterator & r )
342 {
343   SEC << *l << " - " << *r << endl;
344   INT << "== " << (l==r) << endl;
345   INT << "!= " << (l!=r) << endl;
346 }
347
348 bool isTrue()  { return true; }
349 bool isFalse() { return false; }
350
351 void dumpIdStr()
352 {
353   for ( int i = -3; i < 30; ++i )
354   {
355     DBG << i << '\t' << IdString( i ) << endl;
356   }
357 }
358
359 void ttt( const char * lhs, const char * rhs )
360 {
361   DBG << lhs << " <=> " << rhs << " --> " << ::strcmp( lhs, rhs ) << endl;
362 }
363
364 namespace filter
365 {
366   template <class _MemFun, class _Value>
367   class HasValue
368   {
369     public:
370       HasValue( _MemFun fun_r, _Value val_r )
371       : _fun( fun_r ), _val( val_r )
372       {}
373       template <class _Tp>
374       bool operator()( const _Tp & obj_r ) const
375       { return( _fun && (obj_r.*_fun)() == _val ); }
376     private:
377       _MemFun _fun;
378       _Value  _val;
379   };
380
381   template <class _MemFun, class _Value>
382   HasValue<_MemFun, _Value> byValue( _MemFun fun_r, _Value val_r )
383   { return HasValue<_MemFun, _Value>( fun_r, val_r ); }
384 }
385
386 namespace zypp
387 {
388 }
389
390 template <class L>
391 struct _TestO { _TestO( const L & lhs ) : _lhs( lhs ) {} const L & _lhs; };
392
393 template <class L>
394 std::ostream & operator<<( std::ostream & str, const _TestO<L> & obj )
395 { const L & lhs( obj._lhs); return str << (lhs?'_':'*') << (lhs.empty()?'e':'_') << "'" << lhs << "'"; }
396
397 template <class L>
398 _TestO<L> testO( const L & lhs )
399 { return _TestO<L>( lhs ); }
400
401 template <class L, class R>
402 void testCMP( const L & lhs, const R & rhs )
403 {
404   MIL << "LHS " << testO(lhs) << endl;
405   MIL << "RHS " << rhs << endl;
406
407 #define OUTS(S) DBG << #S << ": " << (S) << endl
408   OUTS( lhs.compare(rhs) );
409   OUTS( lhs != rhs );
410   OUTS( lhs <  rhs );
411   OUTS( lhs <= rhs );
412   OUTS( lhs == rhs );
413   OUTS( lhs >= rhs );
414   OUTS( lhs >  rhs );
415 #undef OUTS
416 }
417
418 ///////////////////////////////////////////////////////////////////
419 namespace zypp
420 { /////////////////////////////////////////////////////////////////
421 ///////////////////////////////////////////////////////////////////
422 namespace sat
423 { /////////////////////////////////////////////////////////////////
424
425   class ByLocaleSupport
426   {
427     private:
428       typedef bool (sat::Solvable::*LS1) (const Locale &) const;
429       typedef bool (sat::Solvable::*LS2) (const LocaleSet &) const;
430
431     public:
432       /** Solvables with locale support. */
433       ByLocaleSupport()
434       : _sel( mem_fun_ref( &sat::Solvable::supportsLocales ) )
435       {}
436
437       /** Solvables supporting \c locale_r. */
438       ByLocaleSupport( const Locale & locale_r )
439       : _sel( bind( mem_fun_ref( (LS1)&sat::Solvable::supportsLocale ), _1, locale_r ) )
440       {}
441
442       /** Solvables supporting at least one locale in \c locales_r. */
443       ByLocaleSupport( const LocaleSet & locales_r )
444       : _sel( bind( boost::mem_fun_ref( (LS2)&sat::Solvable::supportsLocale ), _1, locales_r ) )
445       {}
446
447     public:
448       bool operator()( const sat::Solvable & solv_r ) const
449       { return _sel && _sel( solv_r ); }
450
451
452       template<class _Solv>
453       bool operator()( const _Solv & solv_r ) const
454       { return operator()( solv_r.satSolvable() ); }
455
456     private:
457       function<bool(const sat::Solvable &)> _sel;
458   };
459
460
461   /////////////////////////////////////////////////////////////////
462 } // namespace sat
463 ///////////////////////////////////////////////////////////////////
464
465   /////////////////////////////////////////////////////////////////
466 } // namespace zypp
467 ///////////////////////////////////////////////////////////////////
468
469
470 /******************************************************************
471 **
472 **      FUNCTION NAME : main
473 **      FUNCTION TYPE : int
474 */
475 int main( int argc, char * argv[] )
476 try {
477   //zypp::base::LogControl::instance().logfile( "log.restrict" );
478   INT << "===[START]==========================================" << endl;
479
480   sat::Pool satpool( sat::Pool::instance() );
481   ResPool   pool( ResPool::instance() );
482   USR << "pool: " << pool << endl;
483
484   RepoManager repoManager( makeRepoManager( sysRoot ) );
485   RepoInfoList repos = repoManager.knownRepositories();
486
487   // launch repos
488   for ( RepoInfoList::iterator it = repos.begin(); it != repos.end(); ++it )
489   {
490     RepoInfo & nrepo( *it );
491     SEC << nrepo << endl;
492
493     if ( ! nrepo.enabled() )
494       continue;
495
496     if ( ! repoManager.isCached( nrepo ) || /*force*/false )
497     {
498       if ( repoManager.isCached( nrepo ) )
499       {
500         SEC << "cleanCache" << endl;
501         repoManager.cleanCache( nrepo );
502       }
503       SEC << "refreshMetadata" << endl;
504       repoManager.refreshMetadata( nrepo, RepoManager::RefreshForced );
505       SEC << "buildCache" << endl;
506       repoManager.buildCache( nrepo );
507     }
508   }
509
510   // create from cache:
511   {
512     Measure x( "CREATE FROM CACHE" );
513     for ( RepoInfoList::iterator it = repos.begin(); it != repos.end(); ++it )
514     {
515       RepoInfo & nrepo( *it );
516       if ( ! nrepo.enabled() )
517         continue;
518
519       Measure x( "CREATE FROM CACHE "+nrepo.alias() );
520       repoManager.loadFromCache( nrepo );
521       USR << "pool: " << pool << endl;
522     }
523   }
524
525   if ( 0 )
526   {
527     Measure x( "INIT TARGET" );
528     {
529       getZYpp()->initializeTarget( sysRoot );
530       getZYpp()->target()->load();
531     }
532   }
533
534   USR << "pool: " << pool << endl;
535   ///////////////////////////////////////////////////////////////////
536
537   satpool.addRequestedLocale( Locale("de") );
538   satpool.addRequestedLocale( Locale("cs") );
539
540   LocaleSet s;
541   s.insert( Locale("de") );
542
543 //   MIL << satpool.getAvailableLocales() << endl;
544
545   {
546     Measure x( "de" );
547     sat::ByLocaleSupport f( Locale("de") );
548     for_( it, satpool.filterBegin(f), satpool.filterEnd(f) )
549     {
550       MIL << *it << endl;
551     }
552   }
553
554
555
556
557
558   //MIL << sat::WhatProvides( Capability("amarok") ) << endl;
559   //MIL << sat::WhatProvides( Capability("amarok == 1.4.7-37.4") ) << endl;
560
561   if ( 0 )
562   {
563     Measure x( "Upgrade" );
564     UpgradeStatistics u;
565     getZYpp()->resolver()->doUpgrade( u );
566   }
567
568
569   if ( 0 ) {
570   PoolItem pi ( getPi<Package>("amarok") );
571   MIL << pi << endl;
572   if ( pi )
573   {
574     pi.status().setTransact( true, ResStatus::USER );
575     solve();
576     vdumpPoolStats( USR << "Transacting:"<< endl,
577                     make_filter_begin<resfilter::ByTransact>(pool),
578                     make_filter_end<resfilter::ByTransact>(pool) ) << endl;
579
580   }
581   }
582   //vdumpPoolStats( USR << "Pool:"<< endl, pool.begin(), pool.end() ) << endl;
583   //waitForInput();
584
585   //std::for_each( pool.begin(), pool.end(), Xprint() );
586
587   ///////////////////////////////////////////////////////////////////
588   INT << "===[END]============================================" << endl << endl;
589   zypp::base::LogControl::instance().logNothing();
590   return 0;
591 }
592 catch (...)
593 {}
594