libzypp  17.1.1
PoolImpl.cc
Go to the documentation of this file.
1 /*---------------------------------------------------------------------\
2 | ____ _ __ __ ___ |
3 | |__ / \ / / . \ . \ |
4 | / / \ V /| _/ _/ |
5 | / /__ | | | | | | |
6 | /_____||_| |_| |_| |
7 | |
8 \---------------------------------------------------------------------*/
12 #include <iostream>
13 #include <fstream>
14 #include <boost/mpl/int.hpp>
15 
16 #include "zypp/base/Easy.h"
17 #include "zypp/base/LogTools.h"
18 #include "zypp/base/Gettext.h"
19 #include "zypp/base/Exception.h"
20 #include "zypp/base/Measure.h"
21 #include "zypp/base/WatchFile.h"
22 #include "zypp/base/Sysconfig.h"
23 #include "zypp/base/IOStream.h"
24 
25 #include "zypp/ZConfig.h"
26 
28 #include "zypp/sat/SolvableSet.h"
29 #include "zypp/sat/Pool.h"
30 #include "zypp/Capability.h"
31 #include "zypp/Locale.h"
32 #include "zypp/PoolItem.h"
33 
36 
37 extern "C"
38 {
39 // Workaround libsolv project not providing a common include
40 // directory. (the -devel package does, but the git repo doesn't).
41 // #include <solv/repo_helix.h>
42 int repo_add_helix( ::Repo *repo, FILE *fp, int flags );
43 }
44 
45 using std::endl;
46 
47 #undef ZYPP_BASE_LOGGER_LOGGROUP
48 #define ZYPP_BASE_LOGGER_LOGGROUP "zypp::satpool"
49 
50 // ///////////////////////////////////////////////////////////////////
51 namespace zypp
52 {
54  namespace env
55  {
57  inline int LIBSOLV_DEBUGMASK()
58  {
59  const char * envp = getenv("LIBSOLV_DEBUGMASK");
60  return envp ? str::strtonum<int>( envp ) : 0;
61  }
62  } // namespace env
64  namespace sat
65  {
66 
68  namespace detail
69  {
70 
71  // MPL checks for satlib constants we redefine to avoid
72  // includes and defines.
73  BOOST_MPL_ASSERT_RELATION( noId, ==, STRID_NULL );
74  BOOST_MPL_ASSERT_RELATION( emptyId, ==, STRID_EMPTY );
75 
77  BOOST_MPL_ASSERT_RELATION( systemSolvableId, ==, SYSTEMSOLVABLE );
78 
79  BOOST_MPL_ASSERT_RELATION( solvablePrereqMarker, ==, SOLVABLE_PREREQMARKER );
80  BOOST_MPL_ASSERT_RELATION( solvableFileMarker, ==, SOLVABLE_FILEMARKER );
81 
87 
88  BOOST_MPL_ASSERT_RELATION( namespaceModalias, ==, NAMESPACE_MODALIAS );
89  BOOST_MPL_ASSERT_RELATION( namespaceLanguage, ==, NAMESPACE_LANGUAGE );
90  BOOST_MPL_ASSERT_RELATION( namespaceFilesystem, ==, NAMESPACE_FILESYSTEM );
91 
93 
94  const std::string & PoolImpl::systemRepoAlias()
95  {
96  static const std::string _val( "@System" );
97  return _val;
98  }
99 
101  {
102  static const Pathname _val( "/etc/sysconfig/storage" );
103  return _val;
104  }
105 
107 
108  static void logSat( CPool *, void *data, int type, const char *logString )
109  {
110  // "1234567890123456789012345678901234567890
111  if ( 0 == strncmp( logString, " - no rule created", 19 ) )
112  return;
113  if ( 0 == strncmp( logString, " next rules: 0 0", 19 ) )
114  return;
115 
116  if ( type & (SOLV_FATAL|SOLV_ERROR) ) {
117  L_ERR("libsolv") << logString;
118  } else if ( type & SOLV_DEBUG_STATS ) {
119  L_DBG("libsolv") << logString;
120  } else {
121  L_MIL("libsolv") << logString;
122  }
123  }
124 
125  detail::IdType PoolImpl::nsCallback( CPool *, void * data, detail::IdType lhs, detail::IdType rhs )
126  {
127  // lhs: the namespace identifier, e.g. NAMESPACE:MODALIAS
128  // rhs: the value, e.g. pci:v0000104Cd0000840[01]sv*sd*bc*sc*i*
129  // return: 0 if not supportded
130  // 1 if supported by the system
131  // -1 AFAIK it's also possible to return a list of solvables that support it, but don't know how.
132 
133  static const detail::IdType RET_unsupported = 0;
134  static const detail::IdType RET_systemProperty = 1;
135  switch ( lhs )
136  {
137  case NAMESPACE_LANGUAGE:
138  {
139  const TrackedLocaleIds & localeIds( reinterpret_cast<PoolImpl*>(data)->trackedLocaleIds() );
140  return localeIds.contains( IdString(rhs) ) ? RET_systemProperty : RET_unsupported;
141  }
142  break;
143 
144  case NAMESPACE_MODALIAS:
145  {
146  // modalias strings in capability may be hexencoded because rpm does not allow
147  // ',', ' ' or other special chars.
148  return target::Modalias::instance().query( str::hexdecode( IdString(rhs).c_str() ) )
149  ? RET_systemProperty
150  : RET_unsupported;
151  }
152  break;
153 
154  case NAMESPACE_FILESYSTEM:
155  {
156  const std::set<std::string> & requiredFilesystems( reinterpret_cast<PoolImpl*>(data)->requiredFilesystems() );
157  return requiredFilesystems.find( IdString(rhs).asString() ) != requiredFilesystems.end() ? RET_systemProperty : RET_unsupported;
158  }
159  break;
160 
161  }
162 
163  WAR << "Unhandled " << Capability( lhs ) << " vs. " << Capability( rhs ) << endl;
164  return RET_unsupported;
165  }
166 
168  //
169  // METHOD NAME : PoolMember::myPool
170  // METHOD TYPE : PoolImpl
171  //
172  PoolImpl & PoolMember::myPool()
173  {
174  static PoolImpl _global;
175  return _global;
176  }
177 
179  //
180  // METHOD NAME : PoolImpl::PoolImpl
181  // METHOD TYPE : Ctor
182  //
183  PoolImpl::PoolImpl()
184  : _pool( ::pool_create() )
185  {
186  MIL << "Creating sat-pool." << endl;
187  if ( ! _pool )
188  {
189  ZYPP_THROW( Exception( _("Can not create sat-pool.") ) );
190  }
191  // by now we support only a RPM backend
192  ::pool_setdisttype(_pool, DISTTYPE_RPM );
193 
194  // initialialize logging
195  if ( env::LIBSOLV_DEBUGMASK() )
196  {
197  ::pool_setdebugmask(_pool, env::LIBSOLV_DEBUGMASK() );
198  }
199  else
200  {
201  if ( getenv("ZYPP_LIBSOLV_FULLLOG") || getenv("ZYPP_LIBSAT_FULLLOG") )
202  ::pool_setdebuglevel( _pool, 3 );
203  else if ( getenv("ZYPP_FULLLOG") )
204  ::pool_setdebuglevel( _pool, 2 );
205  else
206  ::pool_setdebugmask(_pool, SOLV_DEBUG_JOB|SOLV_DEBUG_STATS );
207  }
208 
209  ::pool_setdebugcallback( _pool, logSat, NULL );
210 
211  // set namespace callback
212  _pool->nscallback = &nsCallback;
213  _pool->nscallbackdata = (void*)this;
214  }
215 
217  //
218  // METHOD NAME : PoolImpl::~PoolImpl
219  // METHOD TYPE : Dtor
220  //
222  {
223  ::pool_free( _pool );
224  }
225 
227 
228  void PoolImpl::setDirty( const char * a1, const char * a2, const char * a3 )
229  {
230  if ( a1 )
231  {
232  if ( a3 ) MIL << a1 << " " << a2 << " " << a3 << endl;
233  else if ( a2 ) MIL << a1 << " " << a2 << endl;
234  else MIL << a1 << endl;
235  }
236  _serial.setDirty(); // pool content change
237  _availableLocalesPtr.reset(); // available locales may change
238  _multiversionListPtr.reset(); // re-evaluate ZConfig::multiversionSpec.
239 
240  depSetDirty(); // invaldate dependency/namespace related indices
241  }
242 
243  void PoolImpl::localeSetDirty( const char * a1, const char * a2, const char * a3 )
244  {
245  if ( a1 )
246  {
247  if ( a3 ) MIL << a1 << " " << a2 << " " << a3 << endl;
248  else if ( a2 ) MIL << a1 << " " << a2 << endl;
249  else MIL << a1 << endl;
250  }
251  _trackedLocaleIdsPtr.reset(); // requested locales changed
252  depSetDirty(); // invaldate dependency/namespace related indices
253  }
254 
255  void PoolImpl::depSetDirty( const char * a1, const char * a2, const char * a3 )
256  {
257  if ( a1 )
258  {
259  if ( a3 ) MIL << a1 << " " << a2 << " " << a3 << endl;
260  else if ( a2 ) MIL << a1 << " " << a2 << endl;
261  else MIL << a1 << endl;
262  }
263  ::pool_freewhatprovides( _pool );
264  }
265 
266  void PoolImpl::prepare() const
267  {
268  // additional /etc/sysconfig/storage check:
269  static WatchFile sysconfigFile( sysconfigStoragePath(), WatchFile::NO_INIT );
270  if ( sysconfigFile.hasChanged() )
271  {
272  _requiredFilesystemsPtr.reset(); // recreated on demand
273  const_cast<PoolImpl*>(this)->depSetDirty( "/etc/sysconfig/storage change" );
274  }
275  if ( _watcher.remember( _serial ) )
276  {
277  // After repo/solvable add/remove:
278  // set pool architecture
279  ::pool_setarch( _pool, ZConfig::instance().systemArchitecture().asString().c_str() );
280  }
281  if ( ! _pool->whatprovides )
282  {
283  MIL << "pool_createwhatprovides..." << endl;
284 
285  ::pool_addfileprovides( _pool );
286  ::pool_createwhatprovides( _pool );
287  }
288  if ( ! _pool->languages )
289  {
290  // initial seting
291  const_cast<PoolImpl*>(this)->setTextLocale( ZConfig::instance().textLocale() );
292  }
293  }
294 
296 
297  CRepo * PoolImpl::_createRepo( const std::string & name_r )
298  {
299  setDirty(__FUNCTION__, name_r.c_str() );
300  CRepo * ret = ::repo_create( _pool, name_r.c_str() );
301  if ( ret && name_r == systemRepoAlias() )
302  ::pool_set_installed( _pool, ret );
303  return ret;
304  }
305 
306  void PoolImpl::_deleteRepo( CRepo * repo_r )
307  {
308  setDirty(__FUNCTION__, repo_r->name );
309  if ( isSystemRepo( repo_r ) )
311  eraseRepoInfo( repo_r );
312  ::repo_free( repo_r, /*resusePoolIDs*/false );
313  // If the last repo is removed clear the pool to actually reuse all IDs.
314  // NOTE: the explicit ::repo_free above asserts all solvables are memset(0)!
315  if ( !_pool->urepos )
316  {
317  _serialIDs.setDirty(); // Indicate resusePoolIDs - ResPool must also invalidate it's PoolItems
318  ::pool_freeallrepos( _pool, /*resusePoolIDs*/true );
319  }
320  }
321 
322  int PoolImpl::_addSolv( CRepo * repo_r, FILE * file_r )
323  {
324  setDirty(__FUNCTION__, repo_r->name );
325  int ret = ::repo_add_solv( repo_r, file_r, 0 );
326  if ( ret == 0 )
327  _postRepoAdd( repo_r );
328  return ret;
329  }
330 
331  int PoolImpl::_addHelix( CRepo * repo_r, FILE * file_r )
332  {
333  setDirty(__FUNCTION__, repo_r->name );
334  int ret = ::repo_add_helix( repo_r, file_r, 0 );
335  if ( ret == 0 )
336  _postRepoAdd( repo_r );
337  return 0;
338  }
339 
340  void PoolImpl::_postRepoAdd( CRepo * repo_r )
341  {
342  if ( ! isSystemRepo( repo_r ) )
343  {
344  // Filter out unwanted archs
345  std::set<detail::IdType> sysids;
346  {
347  Arch::CompatSet sysarchs( Arch::compatSet( ZConfig::instance().systemArchitecture() ) );
348  for_( it, sysarchs.begin(), sysarchs.end() )
349  sysids.insert( it->id() );
350 
351  // unfortunately libsolv treats src/nosrc as architecture:
352  sysids.insert( ARCH_SRC );
353  sysids.insert( ARCH_NOSRC );
354  }
355 
356  detail::IdType blockBegin = 0;
357  unsigned blockSize = 0;
358  for ( detail::IdType i = repo_r->start; i < repo_r->end; ++i )
359  {
360  CSolvable * s( _pool->solvables + i );
361  if ( s->repo == repo_r && sysids.find( s->arch ) == sysids.end() )
362  {
363  // Remember an unwanted arch entry:
364  if ( ! blockBegin )
365  blockBegin = i;
366  ++blockSize;
367  }
368  else if ( blockSize )
369  {
370  // Free remembered entries
371  ::repo_free_solvable_block( repo_r, blockBegin, blockSize, /*resusePoolIDs*/false );
372  blockBegin = blockSize = 0;
373  }
374  }
375  if ( blockSize )
376  {
377  // Free remembered entries
378  ::repo_free_solvable_block( repo_r, blockBegin, blockSize, /*resusePoolIDs*/false );
379  blockBegin = blockSize = 0;
380  }
381  }
382  }
383 
385  {
386  setDirty(__FUNCTION__, repo_r->name );
387  return ::repo_add_solvable_block( repo_r, count_r );
388  }
389 
390  void PoolImpl::setRepoInfo( RepoIdType id_r, const RepoInfo & info_r )
391  {
392  CRepo * repo( getRepo( id_r ) );
393  if ( repo )
394  {
395  bool dirty = false;
396 
397  // libsolv priority is based on '<', while yum's repoinfo
398  // uses 1(highest)->99(lowest). Thus we use -info_r.priority.
399  if ( repo->priority != int(-info_r.priority()) )
400  {
401  repo->priority = -info_r.priority();
402  dirty = true;
403  }
404 
405  // subpriority is used to e.g. prefer http over dvd iff
406  // both have same priority.
407  int mediaPriority( media::MediaPriority( info_r.url() ) );
408  if ( repo->subpriority != mediaPriority )
409  {
410  repo->subpriority = mediaPriority;
411  dirty = true;
412  }
413 
414  if ( dirty )
415  setDirty(__FUNCTION__, info_r.alias().c_str() );
416  }
417  _repoinfos[id_r] = info_r;
418  }
419 
421 
422  void PoolImpl::setTextLocale( const Locale & locale_r )
423  {
424  std::vector<std::string> fallbacklist;
425  for ( Locale l( locale_r ); l; l = l.fallback() )
426  {
427  fallbacklist.push_back( l.code() );
428  }
429  dumpRangeLine( MIL << "pool_set_languages: ", fallbacklist.begin(), fallbacklist.end() ) << endl;
430 
431  std::vector<const char *> fallbacklist_cstr;
432  for_( it, fallbacklist.begin(), fallbacklist.end() )
433  {
434  fallbacklist_cstr.push_back( it->c_str() );
435  }
436  ::pool_set_languages( _pool, &fallbacklist_cstr.front(), fallbacklist_cstr.size() );
437  }
438 
439  void PoolImpl::initRequestedLocales( const LocaleSet & locales_r )
440  {
441  if ( _requestedLocalesTracker.setInitial( locales_r ) )
442  {
443  localeSetDirty( "initRequestedLocales" );
444  MIL << "Init RequestedLocales: " << _requestedLocalesTracker << " =" << locales_r << endl;
445  }
446  }
447 
448  void PoolImpl::setRequestedLocales( const LocaleSet & locales_r )
449  {
450  if ( _requestedLocalesTracker.set( locales_r ) )
451  {
452  localeSetDirty( "setRequestedLocales" );
453  MIL << "New RequestedLocales: " << _requestedLocalesTracker << " =" << locales_r << endl;
454  }
455  }
456 
457  bool PoolImpl::addRequestedLocale( const Locale & locale_r )
458  {
459  bool done = _requestedLocalesTracker.add( locale_r );
460  if ( done )
461  {
462  localeSetDirty( "addRequestedLocale", locale_r.code().c_str() );
463  MIL << "New RequestedLocales: " << _requestedLocalesTracker << " +" << locale_r << endl;
464  }
465  return done;
466  }
467 
468  bool PoolImpl::eraseRequestedLocale( const Locale & locale_r )
469  {
470  bool done = _requestedLocalesTracker.remove( locale_r );
471  if ( done )
472  {
473  localeSetDirty( "addRequestedLocale", locale_r.code().c_str() );
474  MIL << "New RequestedLocales: " << _requestedLocalesTracker << " -" << locale_r << endl;
475  }
476  return done;
477  }
478 
479 
481  {
482  if ( ! _trackedLocaleIdsPtr )
483  {
485 
486  const base::SetTracker<LocaleSet> & localesTracker( _requestedLocalesTracker );
487  TrackedLocaleIds & localeIds( *_trackedLocaleIdsPtr );
488 
489  // Add current locales+fallback except for added ones
490  for ( Locale lang: localesTracker.current() )
491  {
492  if ( localesTracker.wasAdded( lang ) )
493  continue;
494  for ( ; lang; lang = lang.fallback() )
495  { localeIds.current().insert( IdString(lang) ); }
496  }
497 
498  // Add added locales+fallback except they are already in current
499  for ( Locale lang: localesTracker.added() )
500  {
501  for ( ; lang && localeIds.current().insert( IdString(lang) ).second; lang = lang.fallback() )
502  { localeIds.added().insert( IdString(lang) ); }
503  }
504 
505  // Add removed locales+fallback except they are still in current
506  for ( Locale lang: localesTracker.removed() )
507  {
508  for ( ; lang && ! localeIds.current().count( IdString(lang) ); lang = lang.fallback() )
509  { localeIds.removed().insert( IdString(lang) ); }
510  }
511 
512  // Assert that TrackedLocaleIds::current is not empty.
513  // If, so fill in LanguageCode::enCode as last resort.
514  if ( localeIds.current().empty() )
515  { localeIds.current().insert( IdString(Locale::enCode) ); }
516  }
517  return *_trackedLocaleIdsPtr;
518  }
519 
520 
521  static void _getLocaleDeps( const Capability & cap_r, LocaleSet & store_r )
522  {
523  // Collect locales from any 'namespace:language(lang)' dependency
524  CapDetail detail( cap_r );
525  if ( detail.kind() == CapDetail::EXPRESSION )
526  {
527  switch ( detail.capRel() )
528  {
529  case CapDetail::CAP_AND:
530  case CapDetail::CAP_OR:
531  // expand
532  _getLocaleDeps( detail.lhs(), store_r );
533  _getLocaleDeps( detail.rhs(), store_r );
534  break;
535 
537  if ( detail.lhs().id() == NAMESPACE_LANGUAGE )
538  {
539  store_r.insert( Locale( IdString(detail.rhs().id()) ) );
540  }
541  break;
542 
543  case CapDetail::REL_NONE:
544  case CapDetail::CAP_WITH:
545  case CapDetail::CAP_ARCH:
546  break; // unwanted
547  }
548  }
549  }
550 
552  {
553  if ( !_availableLocalesPtr )
554  {
555  _availableLocalesPtr.reset( new LocaleSet );
556  LocaleSet & localeSet( *_availableLocalesPtr );
557 
558  for ( const Solvable & pi : Pool::instance().solvables() )
559  {
560  for ( const Capability & cap : pi.supplements() )
561  {
562  _getLocaleDeps( cap, localeSet );
563  }
564  }
565  }
566  return *_availableLocalesPtr;
567  }
568 
570 
572  {
575 
577  for ( const std::string & spec : ZConfig::instance().multiversionSpec() )
578  {
579  static const std::string prefix( "provides:" );
580  bool provides = str::hasPrefix( spec, prefix );
581 
582  for ( Solvable solv : WhatProvides( Capability( provides ? spec.c_str() + prefix.size() : spec.c_str() ) ) )
583  {
584  if ( provides || solv.ident() == spec )
585  multiversionList.insert( solv );
586  }
587 
588  MultiversionList::size_type nsize = multiversionList.size();
589  MIL << "Multiversion install " << spec << ": " << (nsize-size) << " matches" << endl;
590  size = nsize;
591  }
592  }
593 
595  { _multiversionListPtr.reset(); }
596 
598  {
599  if ( ! _multiversionListPtr )
601  return *_multiversionListPtr;
602  }
603 
604  bool PoolImpl::isMultiversion( const Solvable & solv_r ) const
605  { return multiversionList().contains( solv_r ); }
606 
608 
609  const std::set<std::string> & PoolImpl::requiredFilesystems() const
610  {
611  if ( ! _requiredFilesystemsPtr )
612  {
613  _requiredFilesystemsPtr.reset( new std::set<std::string> );
614  std::set<std::string> & requiredFilesystems( *_requiredFilesystemsPtr );
616  std::inserter( requiredFilesystems, requiredFilesystems.end() ) );
617  }
618  return *_requiredFilesystemsPtr;
619  }
620 
622  } // namespace detail
625  } // namespace sat
628 } // namespace zypp
static const SolvableIdType noSolvableId(0)
Id to denote Solvable::noSolvable.
static const IdType namespaceModalias(18)
bool contains(const TSolv &solv_r) const
Definition: SolvableSet.h:68
bool contains(const key_type &key_r) const
Whether val_r is in the set.
Definition: SetTracker.h:129
unsigned priority() const
Repository priority for solver.
Definition: RepoInfo.cc:354
Interface to gettext.
#define MIL
Definition: Logger.h:64
const Pathname & sysconfigStoragePath()
Definition: PoolImpl.cc:100
CapRel capRel() const
Definition: Capability.h:353
int IdType
Generic Id type.
Definition: PoolMember.h:104
A Solvable object within the sat Pool.
Definition: Solvable.h:53
Container of Solvable providing a Capability (read only).
Definition: WhatProvides.h:87
Capability lhs() const
Definition: Capability.h:352
bool eraseRequestedLocale(const Locale &locale_r)
User change (tracked).
Definition: PoolImpl.cc:468
scoped_ptr< LocaleSet > _availableLocalesPtr
Definition: PoolImpl.h:331
std::string code() const
Return the locale code asString.
Definition: Locale.h:88
Track added/removed set items based on an initial set.
Definition: SetTracker.h:37
std::string asString(const DefaultIntegral< Tp, TInitial > &obj)
#define ZYPP_THROW(EXCPT)
Drops a logline and throws the Exception.
Definition: Exception.h:392
static ZConfig & instance()
Singleton ctor.
Definition: Resolver.cc:125
void multiversionListInit() const
Definition: PoolImpl.cc:571
static const Locale enCode
Last resort "en".
Definition: Locale.h:77
bool remember(unsigned serial_r) const
Return isDirty, storing serial_r as new value.
Definition: SerialNumber.h:160
Locale textLocale() const
The locale for translated texts zypp uses.
Definition: ZConfig.cc:857
Helper providing more detailed information about a Capability.
Definition: Capability.h:298
int _addSolv(CRepo *repo_r, FILE *file_r)
Adding solv file to a repo.
Definition: PoolImpl.cc:322
base::SetTracker< LocaleSet > _requestedLocalesTracker
Definition: PoolImpl.h:328
#define L_MIL(GROUP)
Definition: Logger.h:73
::_Repo CRepo
Wrapped libsolv C data type exposed as backdoor.
Definition: PoolMember.h:63
bool addRequestedLocale(const Locale &locale_r)
User change (tracked).
Definition: PoolImpl.cc:457
#define L_ERR(GROUP)
Definition: Logger.h:75
void setDirty(const char *a1=0, const char *a2=0, const char *a3=0)
Invalidate housekeeping data (e.g.
Definition: PoolImpl.cc:228
bool set(set_type new_r)
Set a new_r set and track changes.
Definition: SetTracker.h:78
const std::set< std::string > & requiredFilesystems() const
accessor for etc/sysconfig/storage reading file on demand
Definition: PoolImpl.cc:609
::_Repo * RepoIdType
Id type to connect Repo and sat-repo.
Definition: PoolMember.h:133
bool hasChanged()
Definition: WatchFile.h:80
bool setInitial()
(Re-)Start tracking the current set (discards previously tracked changes).
Definition: SetTracker.h:57
const MultiversionList & multiversionList() const
Definition: PoolImpl.cc:597
void _deleteRepo(CRepo *repo_r)
Delete repo repo_r from pool.
Definition: PoolImpl.cc:306
std::set< Arch, CompareByGT< Arch > > CompatSet
Reversed arch order, best Arch first.
Definition: Arch.h:117
Locale fallback() const
Return the fallback locale for this locale, if no fallback exists the empty Locale::noCode.
Definition: Locale.cc:208
::_Pool CPool
Wrapped libsolv C data type exposed as backdoor.
Definition: PoolMember.h:61
bool wasAdded(const key_type &key_r) const
Whether val_r is tracked as added.
Definition: SetTracker.h:132
unsigned SolvableIdType
Id type to connect Solvable and sat-solvable.
Definition: PoolMember.h:125
void eraseRepoInfo(RepoIdType id_r)
Definition: PoolImpl.h:210
What is known about a repository.
Definition: RepoInfo.h:71
Access to the sat-pools string space.
Definition: IdString.h:41
unsigned split(const C_Str &line_r, TOutputIterator result_r, const C_Str &sepchars_r=" \)
Split line_r into words.
Definition: String.h:519
#define for_(IT, BEG, END)
Convenient for-loops using iterator.
Definition: Easy.h:27
detail::SolvableIdType _addSolvables(CRepo *repo_r, unsigned count_r)
Adding Solvables to a repo.
Definition: PoolImpl.cc:384
void localeSetDirty(const char *a1=0, const char *a2=0, const char *a3=0)
Invalidate locale related housekeeping data.
Definition: PoolImpl.cc:243
::_Solvable CSolvable
Wrapped libsolv C data type exposed as backdoor.
Definition: PoolMember.h:64
static const IdType solvableFileMarker(16)
map< string, string > read(const Pathname &_path)
Read sysconfig file path_r and return (key,valye) pairs.
Definition: Sysconfig.cc:34
CRepo * getRepo(RepoIdType id_r) const
Definition: PoolImpl.h:168
Remember a files attributes to detect content changes.
Definition: WatchFile.h:49
const set_type & removed() const
Return the set of removed items.
Definition: SetTracker.h:145
sat::detail::IdType id() const
Expert backdoor.
Definition: Capability.h:253
bool isSystemRepo(CRepo *repo_r) const
Definition: PoolImpl.h:99
int repo_add_helix(::Repo *repo, FILE *fp, int flags)
Url url() const
Pars pro toto: The first repository url.
Definition: RepoInfo.h:131
static detail::IdType nsCallback(CPool *, void *data, detail::IdType lhs, detail::IdType rhs)
Callback to resolve namespace dependencies (language, modalias, filesystem, etc.).
Definition: PoolImpl.cc:125
static Pool instance()
Singleton ctor.
Definition: Pool.h:53
static const IdType emptyId(1)
void setRepoInfo(RepoIdType id_r, const RepoInfo &info_r)
Also adjust repo priority and subpriority accordingly.
Definition: PoolImpl.cc:390
const TrackedLocaleIds & trackedLocaleIds() const
Expanded _requestedLocalesTracker for solver.
Definition: PoolImpl.cc:480
SerialNumberWatcher _watcher
Watch serial number.
Definition: PoolImpl.h:323
std::string alias() const
unique identifier for this source.
static const SolvableIdType systemSolvableId(1)
Id to denote the usually hidden Solvable::systemSolvable.
void setRequestedLocales(const LocaleSet &locales_r)
User change (tracked).
Definition: PoolImpl.cc:448
const set_type & current() const
Return the current set.
Definition: SetTracker.h:139
#define WAR
Definition: Logger.h:65
bool add(const value_type &val_r)
Add an element to the set and track changes.
Definition: SetTracker.h:100
sat::StringQueue _autoinstalled
Definition: PoolImpl.h:338
const set_type & added() const
Return the set of added items.
Definition: SetTracker.h:142
#define _(MSG)
Definition: Gettext.h:29
SerialNumber _serialIDs
Serial number of IDs - changes whenever resusePoolIDs==true - ResPool must also invalidate it&#39;s PoolI...
Definition: PoolImpl.h:321
static const IdType namespaceFilesystem(21)
bool query(IdString cap_r) const
Checks if a device on the system matches a modalias pattern.
Definition: Modalias.h:69
Kind kind() const
Definition: Capability.h:334
static CompatSet compatSet(const Arch &targetArch_r)
Return a set of all Arch&#39;s compatibleWith a targetArch_r.
Definition: Arch.cc:550
void prepare() const
Update housekeeping data (e.g.
Definition: PoolImpl.cc:266
bool isMultiversion(const Solvable &solv_r) const
Definition: PoolImpl.cc:604
&#39;Language[_Country]&#39; codes.
Definition: Locale.h:49
void _postRepoAdd(CRepo *repo_r)
Helper postprocessing the repo after adding solv or helix files.
Definition: PoolImpl.cc:340
SerialNumber _serial
Serial number - changes with each Pool content change.
Definition: PoolImpl.h:319
scoped_ptr< MultiversionList > _multiversionListPtr
Definition: PoolImpl.h:335
#define L_DBG(GROUP)
Definition: Logger.h:72
static Modalias & instance()
Singleton access.
Definition: Modalias.cc:198
void depSetDirty(const char *a1=0, const char *a2=0, const char *a3=0)
Invalidate housekeeping data (e.g.
Definition: PoolImpl.cc:255
static void logSat(CPool *, void *data, int type, const char *logString)
Definition: PoolImpl.cc:108
Base class for Exception.
Definition: Exception.h:145
scoped_ptr< std::set< std::string > > _requiredFilesystemsPtr
filesystems mentioned in /etc/sysconfig/storage
Definition: PoolImpl.h:341
void setTextLocale(const Locale &locale_r)
Definition: PoolImpl.cc:422
void clear()
Clear the queue.
Definition: Queue.cc:94
static const IdType namespaceLanguage(20)
std::map< RepoIdType, RepoInfo > _repoinfos
Additional RepoInfo.
Definition: PoolImpl.h:325
int LIBSOLV_DEBUGMASK()
Definition: PoolImpl.cc:57
A sat capability.
Definition: Capability.h:59
void initRequestedLocales(const LocaleSet &locales_r)
Start tracking changes based on this locales_r.
Definition: PoolImpl.cc:439
static const std::string & systemRepoAlias()
Reserved system repository alias .
Definition: PoolImpl.cc:94
static void _getLocaleDeps(const Capability &cap_r, LocaleSet &store_r)
Definition: PoolImpl.cc:521
static const IdType noId(0)
CPool * _pool
sat-pool.
Definition: PoolImpl.h:317
std::ostream & dumpRangeLine(std::ostream &str, TIterator begin, TIterator end)
Print range defined by iterators (single line style).
Definition: LogTools.h:114
static const IdType solvablePrereqMarker(15)
Internal ids satlib includes in dependencies.
const LocaleSet & getAvailableLocales() const
All Locales occurring in any repo.
Definition: PoolImpl.cc:551
bool remove(const value_type &val_r)
Remove an element from the set and track changes.
Definition: SetTracker.h:114
scoped_ptr< TrackedLocaleIds > _trackedLocaleIdsPtr
Definition: PoolImpl.h:329
Derive a numeric priority from Url scheme according to zypp.conf(download.media_preference).
Definition: MediaPriority.h:43
Container::size_type size_type
Definition: SolvableSet.h:42
Capability rhs() const
Definition: Capability.h:354
BOOST_MPL_ASSERT_RELATION(namespaceFilesystem,==, NAMESPACE_FILESYSTEM)
Easy-to use interface to the ZYPP dependency resolver.
Definition: CodePitfalls.doc:1
size_type size() const
Size of the set.
Definition: SolvableSet.h:63
int _addHelix(CRepo *repo_r, FILE *file_r)
Adding helix file to a repo.
Definition: PoolImpl.cc:331
bool hasPrefix(const C_Str &str_r, const C_Str &prefix_r)
Return whether str_r has prefix prefix_r.
Definition: String.h:1028
CRepo * _createRepo(const std::string &name_r)
Creating a new repo named name_r.
Definition: PoolImpl.cc:297
std::unordered_set< Locale > LocaleSet
Definition: Locale.h:27
std::string hexdecode(const C_Str &str_r)
Decode hexencoded XX sequences.
Definition: String.cc:143
bool insert(const TSolv &solv_r)
Insert a Solvable.
Definition: SolvableSet.h:88
Solvable set wrapper to allow adding additional convenience iterators.
Definition: SolvableSet.h:35