devel/devel.ma/DumpSolv.cc

   1 #include "Tools.h"
   2
   3 #include <zypp/ResObjects.h>
   4 #include <zypp/sat/WhatObsoletes.h>
   5
   6
   7 static std::string appname( __FILE__ );
   8 static TestSetup test;
   9
  10 ///////////////////////////////////////////////////////////////////
  11
  12 #define OUT   USR
  13 #define HEADL SEC << "===> "
  14
  15 inline std::ostream & errmessage( const std::string & msg_r = std::string() )
  16 {
  17   cerr << "*** ";
  18   if ( ! msg_r.empty() )
  19     cerr << msg_r << endl;
  20   return cerr;
  21 }
  22
  23 int usage( const std::string & msg_r = std::string(), int exit_r = 100 )
  24 {
  25   if ( ! msg_r.empty() )
  26   {
  27     cerr << endl;
  28     errmessage( msg_r );
  29     cerr << endl;
  30   }
  31   cerr << "Usage: " << appname << " TESTCASE" << endl;
  32   cerr << "  Load and process testcase." << endl;
  33   return exit_r;
  34 }
  35
  36 ///////////////////////////////////////////////////////////////////
  37
  38 bool upgrade()
  39 {
  40   bool rres = false;
  41   {
  42     zypp::base::LogControl::TmpLineWriter shutUp;
  43     rres = getZYpp()->resolver()->doUpgrade();
  44   }
  45   if ( ! rres )
  46   {
  47     ERR << "upgrade " << rres << endl;
  48     getZYpp()->resolver()->problems();
  49     return false;
  50   }
  51   MIL << "upgrade " << rres << endl;
  52   return true;
  53 }
  54
  55 bool solve()
  56 {
  57   static unsigned run = 0;
  58   USR << "Solve " << run++ << endl;
  59   bool rres = false;
  60   {
  61     zypp::base::LogControl::TmpLineWriter shutUp;
  62     rres = getZYpp()->resolver()->resolvePool();
  63   }
  64   if ( ! rres )
  65   {
  66     ERR << "resolve " << rres << endl;
  67     getZYpp()->resolver()->problems();
  68     return false;
  69   }
  70
  71   return true;
  72 }
  73
  74 ///////////////////////////////////////////////////////////////////
  75
  76 /**
  77 */
  78 struct ArgList
  79 {
  80   typedef std::vector<std::string>::const_iterator const_iterator;
  81
  82   ArgList()
  83   {}
  84
  85   ArgList( const std::string & line_r )
  86   { str::splitEscaped( line_r, std::back_inserter(_argv) ); }
  87
  88   const_iterator begin() const { const_iterator ret =_argv.begin(); for ( unsigned i = _carg; i; --i ) ++ret; return ret; }
  89   const_iterator end()   const { return _argv.end(); }
  90
  91   void     clear()       { _argv.clear(); _carg = 0; }
  92   bool     empty() const { return _argv.size() == _carg; }
  93   unsigned size()  const { return _argv.size() - _carg; }
  94
  95   std::string &       operator[]( int idx )       { return _argv[_carg+idx]; }
  96   const std::string & operator[]( int idx ) const { return _argv[_carg+idx]; }
  97
  98   std::string at( int idx ) const { return _carg+idx < _argv.size() ? _argv[_carg+idx] : std::string(); }
  99
 100   unsigned carg() const { return _carg; }
 101   void poparg( int cnt = 1 ) { _carg = arange( _carg + cnt ); }
 102
 103   public:
 104     std::vector<std::string> &       get()       { return _argv; }
 105     const std::vector<std::string> & get() const { return _argv; }
 106  private:
 107    unsigned arange( int idx ) const { return idx < 0 ? 0 : std::min( unsigned(idx), _argv.size() ); }
 108  private:
 109     DefaultIntegral<unsigned,0> _carg;
 110     std::vector<std::string> _argv;
 111 };
 112
 113 std::ostream & operator<<( std::ostream & str, const ArgList & obj )
 114 {
 115   for_( it, 0U, obj.get().size() )
 116   {
 117     str << ( it == obj.carg() ? " | " : " " ) << obj.get()[it];
 118   }
 119   return str;
 120 }
 121
 122 ///////////////////////////////////////////////////////////////////
 123 #define DELGATE(N,F) if ( argv.at(0) == #N ) { argv.poparg(); F( argv ); return; }
 124 ///////////////////////////////////////////////////////////////////
 125
 126 void exitCmd( ArgList & argv )
 127 {
 128   HEADL << argv << endl;
 129   INT << "===[END]============================================" << endl << endl;
 130   zypp::base::LogControl::TmpLineWriter shutUp;
 131   ::exit( 0 );
 132 }
 133
 134 ///////////////////////////////////////////////////////////////////
 135
 136 void helpCmd( ArgList & argv )
 137 {
 138   HEADL << argv << endl;
 139   OUT << "list repos   - list repos in pool" << endl;
 140   OUT << "list NAME... - list solvables named or providing NAME" << endl;
 141   OUT << "help         - this" << endl;
 142   OUT << "exit         - exit" << endl;
 143 }
 144
 145 ///////////////////////////////////////////////////////////////////
 146
 147 void listReposCmd( ArgList & argv )
 148 {
 149   HEADL << "list repos" << endl;
 150
 151   sat::Pool satpool( test.satpool() );
 152   for_( it, satpool.reposBegin(), satpool.reposEnd() )
 153   {
 154     OUT << *it << endl;
 155   }
 156 }
 157
 158 void listIdent( IdString ident_r )
 159 {
 160   HEADL << "list " << ident_r << endl;
 161
 162   ui::Selectable::Ptr sel( ui::Selectable::get( ident_r ) );
 163   if ( sel )
 164   {
 165     OUT << sel->ident()
 166         << " I" << sel->installedSize()
 167         << " A" << sel->availableSize()
 168         << " " << sel->status()
 169         << endl;
 170     for_( it, sel->installedBegin(), sel->installedEnd() )
 171     {
 172       OUT << "i " << *it << endl;
 173     }
 174     PoolItem cand( sel->candidateObj() );
 175     for_( it, sel->availableBegin(), sel->availableEnd() )
 176     {
 177       OUT << (*it == cand ? "* " : "  ") << *it << endl;
 178     }
 179   }
 180
 181   {
 182     sat::WhatProvides q( (Capability( ident_r.id() )) );
 183     bool head = true;
 184     for_( it, q.begin(), q.end() )
 185     {
 186       if ( it->ident() != ident_r )
 187       {
 188         if ( head )
 189         {
 190           OUT << "provided by:" << endl;
 191           head = false;
 192         }
 193         OUT << "  " << PoolItem( *it ) << endl;
 194       }
 195     }
 196   }
 197 }
 198
 199
 200 void listCmd( ArgList & argv )
 201 {
 202   DELGATE( repos, listReposCmd );
 203
 204   for_( it, argv.begin(), argv.end() )
 205   {
 206     listIdent( IdString(*it) );
 207   }
 208 }
 209
 210 ///////////////////////////////////////////////////////////////////
 211
 212 void gocmd( ArgList & argv )
 213 {
 214   if ( argv.empty() )
 215   {
 216     helpCmd( argv );
 217     return;
 218   }
 219
 220   switch ( argv[0][0] )
 221   {
 222     case 'e':
 223       DELGATE( exit, exitCmd );
 224       break;
 225
 226     case 'h':
 227       DELGATE( help, helpCmd );
 228       break;
 229
 230     case 'l':
 231       DELGATE( list, listCmd );
 232       break;
 233   }
 234   // no command fall back to list
 235   listCmd( argv );
 236 }
 237
 238 void goprompt()
 239 {
 240   std::cin.tie( &std::cout );
 241
 242   do {
 243     ArgList argv;
 244     std::cout << "Hallo : ";
 245     str::splitEscaped( iostr::getline( std::cin ), std::back_inserter(argv.get()) );
 246     gocmd( argv );
 247   } while ( true );
 248
 249 }
 250
 251 ///////////////////////////////////////////////////////////////////
 252
 253 /******************************************************************
 254 **
 255 **      FUNCTION NAME : main
 256 **      FUNCTION TYPE : int
 257 */
 258 int main( int argc, char * argv[] )
 259 {
 260   INT << "===[START]==========================================" << endl;
 261   appname = Pathname::basename( argv[0] );
 262   --argc;
 263   ++argv;
 264   ///////////////////////////////////////////////////////////////////
 265
 266   if ( !argc )
 267     return usage();
 268
 269   Pathname mtest( *argv );
 270   --argc;
 271   ++argv;
 272
 273   if ( ! PathInfo( mtest / "solver-test.xml" ).isFile() )
 274   {
 275     return usage( "No testcase at " + mtest.asString() );
 276   }
 277
 278   ///////////////////////////////////////////////////////////////////
 279
 280   test.loadTestcaseRepos( mtest ); // <<< repos
 281 #define GOCMD(c) { ArgList argv( #c ); gocmd( argv ); }
 282   GOCMD( tgt );
 283   GOCMD( iscsitarget );
 284   goprompt();
 285
 286   INT << "===[END]============================================" << endl << endl;
 287   zypp::base::LogControl::TmpLineWriter shutUp;
 288   return 0;
 289 }