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