libzypp 17.32.2
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-core/fs/WatchFile>
22#include <zypp-core/parser/Sysconfig>
23#include <zypp/base/IOStream.h>
24
25#include <zypp/ZConfig.h>
26
27#include <zypp/sat/detail/PoolImpl.h>
29#include <zypp/sat/Pool.h>
30#include <zypp/Capability.h>
31#include <zypp/Locale.h>
32#include <zypp/PoolItem.h>
33
36
37extern "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// #include <solv/testcase.h>
43int repo_add_helix( ::Repo *repo, FILE *fp, int flags );
44int testcase_add_testtags(Repo *repo, FILE *fp, int flags);
45}
46
47using std::endl;
48
49#undef ZYPP_BASE_LOGGER_LOGGROUP
50#define ZYPP_BASE_LOGGER_LOGGROUP "zypp::satpool"
51
52// ///////////////////////////////////////////////////////////////////
53namespace zypp
54{
56 namespace env
57 {
59 inline int LIBSOLV_DEBUGMASK()
60 {
61 const char * envp = getenv("LIBSOLV_DEBUGMASK");
62 return envp ? str::strtonum<int>( envp ) : 0;
63 }
64 } // namespace env
66 namespace sat
67 {
68
70 namespace detail
71 {
72
73 // MPL checks for satlib constants we redefine to avoid
74 // includes and defines.
77
78 BOOST_MPL_ASSERT_RELATION( noSolvableId, ==, ID_NULL );
80
83
93
97
99
100 const std::string & PoolImpl::systemRepoAlias()
101 {
102 static const std::string _val( "@System" );
103 return _val;
104 }
105
107 {
108 static const Pathname _val( "/etc/sysconfig/storage" );
109 return _val;
110 }
111
113
114 static void logSat( CPool *, void *data, int type, const char *logString )
115 {
116 // "1234567890123456789012345678901234567890
117 if ( 0 == strncmp( logString, "job: drop orphaned", 18 ) )
118 return;
119 if ( 0 == strncmp( logString, "job: user installed", 19 ) )
120 return;
121 if ( 0 == strncmp( logString, "job: multiversion", 17 ) )
122 return;
123 if ( 0 == strncmp( logString, " - no rule created", 19 ) )
124 return;
125 if ( 0 == strncmp( logString, " next rules: 0 0", 19 ) )
126 return;
127
128 if ( type & (SOLV_FATAL|SOLV_ERROR) ) {
129 L_ERR("libsolv") << logString;
130 } else if ( type & SOLV_DEBUG_STATS ) {
131 L_DBG("libsolv") << logString;
132 } else {
133 L_MIL("libsolv") << logString;
134 }
135 }
136
138 {
139 // lhs: the namespace identifier, e.g. NAMESPACE:MODALIAS
140 // rhs: the value, e.g. pci:v0000104Cd0000840[01]sv*sd*bc*sc*i*
141 // return: 0 if not supportded
142 // 1 if supported by the system
143 // -1 AFAIK it's also possible to return a list of solvables that support it, but don't know how.
144
145 static const detail::IdType RET_unsupported = 0;
146 static const detail::IdType RET_systemProperty = 1;
147 switch ( lhs )
148 {
150 {
151 const TrackedLocaleIds & localeIds( reinterpret_cast<PoolImpl*>(data)->trackedLocaleIds() );
152 return localeIds.contains( IdString(rhs) ) ? RET_systemProperty : RET_unsupported;
153 }
154 break;
155
157 {
158 // modalias strings in capability may be hexencoded because rpm does not allow
159 // ',', ' ' or other special chars.
160 return target::Modalias::instance().query( str::hexdecode( IdString(rhs).c_str() ) )
163 }
164 break;
165
167 {
168 const std::set<std::string> & requiredFilesystems( reinterpret_cast<PoolImpl*>(data)->requiredFilesystems() );
170 }
171 break;
172
173 }
174
175 WAR << "Unhandled " << Capability( lhs ) << " vs. " << Capability( rhs ) << endl;
176 return RET_unsupported;
177 }
178
180 //
181 // METHOD NAME : PoolMember::myPool
182 // METHOD TYPE : PoolImpl
183 //
185 {
186 static PoolImpl _global;
187 return _global;
188 }
189
191 //
192 // METHOD NAME : PoolImpl::PoolImpl
193 // METHOD TYPE : Ctor
194 //
196 : _pool( ::pool_create() )
197 {
198 MIL << "Creating sat-pool." << endl;
199 if ( ! _pool )
200 {
201 ZYPP_THROW( Exception( _("Can not create sat-pool.") ) );
202 }
203 // by now we support only a RPM backend
204 ::pool_setdisttype(_pool, DISTTYPE_RPM );
205
206 // initialialize logging
208 {
209 ::pool_setdebugmask(_pool, env::LIBSOLV_DEBUGMASK() );
210 }
211 else
212 {
213 if ( getenv("ZYPP_LIBSOLV_FULLLOG") || getenv("ZYPP_LIBSAT_FULLLOG") )
214 ::pool_setdebuglevel( _pool, 3 );
215 else if ( getenv("ZYPP_FULLLOG") )
216 ::pool_setdebuglevel( _pool, 2 );
217 else
218 ::pool_setdebugmask(_pool, SOLV_DEBUG_JOB|SOLV_DEBUG_STATS );
219 }
220
221 ::pool_setdebugcallback( _pool, logSat, NULL );
222
223 // set namespace callback
224 _pool->nscallback = &nsCallback;
225 _pool->nscallbackdata = (void*)this;
226
227 // CAVEAT: We'd like to do it here, but in side the Pool ctor we can not
228 // yet use IdString types. We do in setDirty, when the 1st
229 // _retractedSpec.addProvides( Capability( Solvable::retractedToken.id() ) );
230 // _ptfMasterSpec.addProvides( Capability( Solvable::ptfMasterToken.id() ) );
231 // _ptfPackageSpec.addProvides( Capability( Solvable::ptfPackageToken.id() ) );
232 _retractedSpec.addIdenticalInstalledToo( true ); // retracted indicator is not part of the package!
233 }
234
236 //
237 // METHOD NAME : PoolImpl::~PoolImpl
238 // METHOD TYPE : Dtor
239 //
241 {
242 ::pool_free( _pool );
243 }
244
246
247 void PoolImpl::setDirty( const char * a1, const char * a2, const char * a3 )
248 {
249 if ( _retractedSpec.empty() ) {
250 // lazy init IdString types we can not use inside the ctor
254 }
255
256 if ( a1 )
257 {
258 if ( a3 ) MIL << a1 << " " << a2 << " " << a3 << endl;
259 else if ( a2 ) MIL << a1 << " " << a2 << endl;
260 else MIL << a1 << endl;
261 }
262 _serial.setDirty(); // pool content change
263 _availableLocalesPtr.reset(); // available locales may change
264 _multiversionListPtr.reset(); // re-evaluate ZConfig::multiversionSpec.
265 _needrebootSpec.setDirty(); // re-evaluate needrebootSpec
266
267 _retractedSpec.setDirty(); // re-evaluate blacklisted spec
268 _ptfMasterSpec.setDirty(); // --"--
269 _ptfPackageSpec.setDirty(); // --"--
270
271 depSetDirty(); // invaldate dependency/namespace related indices
272 }
273
274 void PoolImpl::localeSetDirty( const char * a1, const char * a2, const char * a3 )
275 {
276 if ( a1 )
277 {
278 if ( a3 ) MIL << a1 << " " << a2 << " " << a3 << endl;
279 else if ( a2 ) MIL << a1 << " " << a2 << endl;
280 else MIL << a1 << endl;
281 }
282 _trackedLocaleIdsPtr.reset(); // requested locales changed
283 depSetDirty(); // invaldate dependency/namespace related indices
284 }
285
286 void PoolImpl::depSetDirty( const char * a1, const char * a2, const char * a3 )
287 {
288 if ( a1 )
289 {
290 if ( a3 ) MIL << a1 << " " << a2 << " " << a3 << endl;
291 else if ( a2 ) MIL << a1 << " " << a2 << endl;
292 else MIL << a1 << endl;
293 }
294 ::pool_freewhatprovides( _pool );
295 }
296
297 void PoolImpl::prepare() const
298 {
299 // additional /etc/sysconfig/storage check:
301 if ( sysconfigFile.hasChanged() )
302 {
303 _requiredFilesystemsPtr.reset(); // recreated on demand
304 const_cast<PoolImpl*>(this)->depSetDirty( "/etc/sysconfig/storage change" );
305 }
306 if ( _watcher.remember( _serial ) )
307 {
308 // After repo/solvable add/remove:
309 // set pool architecture
310 ::pool_setarch( _pool, ZConfig::instance().systemArchitecture().asString().c_str() );
311 }
312 if ( ! _pool->whatprovides )
313 {
314 MIL << "pool_createwhatprovides..." << endl;
315
316 ::pool_addfileprovides( _pool );
317 ::pool_createwhatprovides( _pool );
318 }
319 if ( ! _pool->languages )
320 {
321 // initial seting
322 const_cast<PoolImpl*>(this)->setTextLocale( ZConfig::instance().textLocale() );
323 }
324 }
325
327
328 CRepo * PoolImpl::_createRepo( const std::string & name_r )
329 {
330 setDirty(__FUNCTION__, name_r.c_str() );
331 CRepo * ret = ::repo_create( _pool, name_r.c_str() );
332 if ( ret && name_r == systemRepoAlias() )
333 ::pool_set_installed( _pool, ret );
334 return ret;
335 }
336
338 {
340 if ( isSystemRepo( repo_r ) )
343 ::repo_free( repo_r, /*resusePoolIDs*/false );
344 // If the last repo is removed clear the pool to actually reuse all IDs.
345 // NOTE: the explicit ::repo_free above asserts all solvables are memset(0)!
346 if ( !_pool->urepos )
347 {
348 _serialIDs.setDirty(); // Indicate resusePoolIDs - ResPool must also invalidate its PoolItems
349 ::pool_freeallrepos( _pool, /*resusePoolIDs*/true );
350 }
351 }
352
354 {
356 int ret = ::repo_add_solv( repo_r, file_r, 0 );
357 if ( ret == 0 )
359 return ret;
360 }
361
363 {
365 int ret = ::repo_add_helix( repo_r, file_r, 0 );
366 if ( ret == 0 )
368 return 0;
369 }
370
372 {
375 if ( ret == 0 )
377 return 0;
378 }
379
381 {
382 if ( ! isSystemRepo( repo_r ) )
383 {
384 // Filter out unwanted archs
385 std::set<detail::IdType> sysids;
386 {
387 Arch::CompatSet sysarchs( Arch::compatSet( ZConfig::instance().systemArchitecture() ) );
388 for_( it, sysarchs.begin(), sysarchs.end() )
389 sysids.insert( it->id() );
390
391 // unfortunately libsolv treats src/nosrc as architecture:
392 sysids.insert( ARCH_SRC );
393 sysids.insert( ARCH_NOSRC );
394 }
395
397 unsigned blockSize = 0;
398 for ( detail::IdType i = repo_r->start; i < repo_r->end; ++i )
399 {
400 CSolvable * s( _pool->solvables + i );
401 if ( s->repo == repo_r && sysids.find( s->arch ) == sysids.end() )
402 {
403 // Remember an unwanted arch entry:
404 if ( ! blockBegin )
405 blockBegin = i;
406 ++blockSize;
407 }
408 else if ( blockSize )
409 {
410 // Free remembered entries
411 ::repo_free_solvable_block( repo_r, blockBegin, blockSize, /*resusePoolIDs*/false );
412 blockBegin = blockSize = 0;
413 }
414 }
415 if ( blockSize )
416 {
417 // Free remembered entries
418 ::repo_free_solvable_block( repo_r, blockBegin, blockSize, /*resusePoolIDs*/false );
419 blockBegin = blockSize = 0;
420 }
421 }
422 }
423
425 {
427 return ::repo_add_solvable_block( repo_r, count_r );
428 }
429
431 {
432 CRepo * repo( getRepo( id_r ) );
433 if ( repo )
434 {
435 bool dirty = false;
436
437 // libsolv priority is based on '<', while yum's repoinfo
438 // uses 1(highest)->99(lowest). Thus we use -info_r.priority.
439 if ( repo->priority != int(-info_r.priority()) )
440 {
441 repo->priority = -info_r.priority();
442 dirty = true;
443 }
444
445 // subpriority is used to e.g. prefer http over dvd iff
446 // both have same priority.
448 if ( repo->subpriority != mediaPriority )
449 {
450 repo->subpriority = mediaPriority;
451 dirty = true;
452 }
453
454 if ( dirty )
455 setDirty(__FUNCTION__, info_r.alias().c_str() );
456 }
458 }
459
461
463 {
464 if ( ! locale_r )
465 {
466 // We need one, so "en" is the last resort
467 const char *needone[] { "en" };
468 ::pool_set_languages( _pool, needone, 1 );
469 return;
470 }
471
472 std::vector<std::string> fallbacklist;
473 for ( Locale l( locale_r ); l; l = l.fallback() )
474 {
475 fallbacklist.push_back( l.code() );
476 }
477 dumpRangeLine( MIL << "pool_set_languages: ", fallbacklist.begin(), fallbacklist.end() ) << endl;
478
479 std::vector<const char *> fallbacklist_cstr;
480 for_( it, fallbacklist.begin(), fallbacklist.end() )
481 {
482 fallbacklist_cstr.push_back( it->c_str() );
483 }
484 ::pool_set_languages( _pool, &fallbacklist_cstr.front(), fallbacklist_cstr.size() );
485 }
486
488 {
490 {
491 localeSetDirty( "initRequestedLocales" );
492 MIL << "Init RequestedLocales: " << _requestedLocalesTracker << " =" << locales_r << endl;
493 }
494 }
495
497 {
499 {
500 localeSetDirty( "setRequestedLocales" );
501 MIL << "New RequestedLocales: " << _requestedLocalesTracker << " =" << locales_r << endl;
502 }
503 }
504
506 {
508 if ( done )
509 {
510 localeSetDirty( "addRequestedLocale", locale_r.code().c_str() );
511 MIL << "New RequestedLocales: " << _requestedLocalesTracker << " +" << locale_r << endl;
512 }
513 return done;
514 }
515
517 {
519 if ( done )
520 {
521 localeSetDirty( "addRequestedLocale", locale_r.code().c_str() );
522 MIL << "New RequestedLocales: " << _requestedLocalesTracker << " -" << locale_r << endl;
523 }
524 return done;
525 }
526
527
529 {
530 if ( ! _trackedLocaleIdsPtr )
531 {
533
536
537 // Add current locales+fallback except for added ones
538 for ( Locale lang: localesTracker.current() )
539 {
540 if ( localesTracker.wasAdded( lang ) )
541 continue;
542 for ( ; lang; lang = lang.fallback() )
543 { localeIds.current().insert( IdString(lang) ); }
544 }
545
546 // Add added locales+fallback except they are already in current
547 for ( Locale lang: localesTracker.added() )
548 {
549 for ( ; lang && localeIds.current().insert( IdString(lang) ).second; lang = lang.fallback() )
550 { localeIds.added().insert( IdString(lang) ); }
551 }
552
553 // Add removed locales+fallback except they are still in current
554 for ( Locale lang: localesTracker.removed() )
555 {
556 for ( ; lang && ! localeIds.current().count( IdString(lang) ); lang = lang.fallback() )
557 { localeIds.removed().insert( IdString(lang) ); }
558 }
559
560 // bsc#1155678: We try to differ between an empty RequestedLocales
561 // and one containing 'en' (explicit or as fallback). An empty RequestedLocales
562 // should not even drag in recommended 'en' packages. So we no longer enforce
563 // 'en' being in the set.
564 }
565 return *_trackedLocaleIdsPtr;
566 }
567
568
570 {
571 // Collect locales from any 'namespace:language(lang)' dependency
572 CapDetail detail( cap_r );
573 if ( detail.kind() == CapDetail::EXPRESSION )
574 {
575 switch ( detail.capRel() )
576 {
579 // expand
580 _getLocaleDeps( detail.lhs(), store_r );
581 _getLocaleDeps( detail.rhs(), store_r );
582 break;
583
585 if ( detail.lhs().id() == NAMESPACE_LANGUAGE )
586 {
587 store_r.insert( Locale( IdString(detail.rhs().id()) ) );
588 }
589 break;
590
591 default:
592 break; // unwanted
593 }
594 }
595 }
596
598 {
600 {
601 _availableLocalesPtr.reset( new LocaleSet );
603
604 for ( const Solvable & pi : Pool::instance().solvables() )
605 {
606 for ( const Capability & cap : pi.supplements() )
607 {
609 }
610 }
611 }
612 return *_availableLocalesPtr;
613 }
614
616
618 {
621
623 for ( const std::string & spec : ZConfig::instance().multiversionSpec() )
624 {
625 static const std::string prefix( "provides:" );
626 bool provides = str::hasPrefix( spec, prefix );
627
628 for ( Solvable solv : WhatProvides( Capability( provides ? spec.c_str() + prefix.size() : spec.c_str() ) ) )
629 {
630 if ( provides || solv.ident() == spec )
632 }
633
635 MIL << "Multiversion install " << spec << ": " << (nsize-size) << " matches" << endl;
636 size = nsize;
637 }
638 }
639
642
649
651 { return multiversionList().contains( solv_r ); }
652
654
655 const std::set<std::string> & PoolImpl::requiredFilesystems() const
656 {
658 {
659 _requiredFilesystemsPtr.reset( new std::set<std::string> );
660 std::set<std::string> & requiredFilesystems( *_requiredFilesystemsPtr );
662 std::inserter( requiredFilesystems, requiredFilesystems.end() ) );
663 }
665 }
666
668 } // namespace detail
671 } // namespace sat
674} // namespace zypp
static CompatSet compatSet(const Arch &targetArch_r)
Return a set of all Arch's compatibleWith a targetArch_r.
Definition Arch.cc:568
std::set< Arch, CompareByGT< Arch > > CompatSet
Reversed arch order, best Arch first.
Definition Arch.h:117
Reference counted access to a Tp object calling a custom Dispose function when the last AutoDispose h...
Definition AutoDispose.h:95
void reset()
Reset to default Ctor values.
Helper providing more detailed information about a Capability.
Definition Capability.h:310
Capability rhs() const
Definition Capability.h:372
Capability lhs() const
Definition Capability.h:370
Kind kind() const
Definition Capability.h:352
CapRel capRel() const
Definition Capability.h:371
@ CAP_WITHOUT
without
Definition Capability.h:334
@ CAP_ARCH
Used internally.
Definition Capability.h:337
@ CAP_UNLESS
unless
Definition Capability.h:330
A sat capability.
Definition Capability.h:63
sat::detail::IdType id() const
Expert backdoor.
Definition Capability.h:263
Base class for Exception.
Definition Exception.h:147
Access to the sat-pools string space.
Definition IdString.h:43
'Language[_Country]' codes.
Definition Locale.h:50
What is known about a repository.
Definition RepoInfo.h:72
bool remember(unsigned serial_r) const
Return isDirty, storing serial_r as new value.
Remember a files attributes to detect content changes.
Definition watchfile.h:50
static ZConfig & instance()
Singleton ctor.
Definition ZConfig.cc:925
Derive a numeric priority from Url scheme according to zypp.conf(download.media_preference).
static Pool instance()
Singleton ctor.
Definition Pool.h:55
void clear()
Clear the queue.
Definition Queue.cc:94
Solvable set wrapper to allow adding additional convenience iterators.
Definition SolvableSet.h:36
Container::size_type size_type
Definition SolvableSet.h:42
size_type size() const
Size of the set.
Definition SolvableSet.h:63
bool insert(const TSolv &solv_r)
Insert a Solvable.
Definition SolvableSet.h:88
bool contains(const TSolv &solv_r) const
Definition SolvableSet.h:68
bool addIdenticalInstalledToo() const
Extend the provides set to include idential installed items as well.
bool empty() const
Whether neither idents nor provides are set.
void setDirty() const
Explicitly flag the cache as dirty, so it will be rebuilt on the next request.
void addProvides(Capability provides_r)
A all sat::Solvable matching this provides_r.
A Solvable object within the sat Pool.
Definition Solvable.h:54
static const IdString ptfMasterToken
Indicator provides ptf()
Definition Solvable.h:59
static const IdString ptfPackageToken
Indicator provides ptf-package()
Definition Solvable.h:60
static const IdString retractedToken
Indicator provides retracted-patch-package()
Definition Solvable.h:58
Container of Solvable providing a Capability (read only).
sat::SolvableSpec _needrebootSpec
Solvables which should trigger the reboot-needed hint if installed/updated.
Definition PoolImpl.h:380
scoped_ptr< TrackedLocaleIds > _trackedLocaleIdsPtr
Definition PoolImpl.h:368
sat::SolvableSpec _retractedSpec
Blacklisted specs:
Definition PoolImpl.h:383
scoped_ptr< LocaleSet > _availableLocalesPtr
Definition PoolImpl.h:370
scoped_ptr< MultiversionList > _multiversionListPtr
Definition PoolImpl.h:374
bool isSystemRepo(CRepo *repo_r) const
Definition PoolImpl.h:101
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:137
CRepo * getRepo(RepoIdType id_r) const
Definition PoolImpl.h:176
void setTextLocale(const Locale &locale_r)
Definition PoolImpl.cc:462
void initRequestedLocales(const LocaleSet &locales_r)
Start tracking changes based on this locales_r.
Definition PoolImpl.cc:487
sat::StringQueue _autoinstalled
Definition PoolImpl.h:377
int _addTesttags(CRepo *repo_r, FILE *file_r)
Adding testtags file to a repo.
Definition PoolImpl.cc:371
void multiversionListInit() const
Definition PoolImpl.cc:617
const LocaleSet & getAvailableLocales() const
All Locales occurring in any repo.
Definition PoolImpl.cc:597
std::map< RepoIdType, RepoInfo > _repoinfos
Additional RepoInfo.
Definition PoolImpl.h:364
void _deleteRepo(CRepo *repo_r)
Delete repo repo_r from pool.
Definition PoolImpl.cc:337
bool eraseRequestedLocale(const Locale &locale_r)
User change (tracked).
Definition PoolImpl.cc:516
sat::SolvableSpec _ptfMasterSpec
Definition PoolImpl.h:384
void eraseRepoInfo(RepoIdType id_r)
Definition PoolImpl.h:223
const TrackedLocaleIds & trackedLocaleIds() const
Expanded _requestedLocalesTracker for solver.
Definition PoolImpl.cc:528
void localeSetDirty(const char *a1=0, const char *a2=0, const char *a3=0)
Invalidate locale related housekeeping data.
Definition PoolImpl.cc:274
scoped_ptr< std::set< std::string > > _requiredFilesystemsPtr
filesystems mentioned in /etc/sysconfig/storage
Definition PoolImpl.h:388
base::SetTracker< LocaleSet > _requestedLocalesTracker
Definition PoolImpl.h:367
void setRequestedLocales(const LocaleSet &locales_r)
User change (tracked).
Definition PoolImpl.cc:496
const MultiversionList & multiversionList() const
Definition PoolImpl.cc:643
CRepo * _createRepo(const std::string &name_r)
Creating a new repo named name_r.
Definition PoolImpl.cc:328
SerialNumberWatcher _watcher
Watch serial number.
Definition PoolImpl.h:362
SerialNumber _serial
Serial number - changes with each Pool content change.
Definition PoolImpl.h:358
const std::set< std::string > & requiredFilesystems() const
accessor for etc/sysconfig/storage reading file on demand
Definition PoolImpl.cc:655
void _postRepoAdd(CRepo *repo_r)
Helper postprocessing the repo after adding solv or helix files.
Definition PoolImpl.cc:380
bool addRequestedLocale(const Locale &locale_r)
User change (tracked).
Definition PoolImpl.cc:505
int _addSolv(CRepo *repo_r, FILE *file_r)
Adding solv file to a repo.
Definition PoolImpl.cc:353
int _addHelix(CRepo *repo_r, FILE *file_r)
Adding helix file to a repo.
Definition PoolImpl.cc:362
sat::SolvableSpec _ptfPackageSpec
Definition PoolImpl.h:385
detail::SolvableIdType _addSolvables(CRepo *repo_r, unsigned count_r)
Adding Solvables to a repo.
Definition PoolImpl.cc:424
SerialNumber _serialIDs
Serial number of IDs - changes whenever resusePoolIDs==true - ResPool must also invalidate its PoolIt...
Definition PoolImpl.h:360
bool isMultiversion(const Solvable &solv_r) const
Definition PoolImpl.cc:650
void prepare() const
Update housekeeping data (e.g.
Definition PoolImpl.cc:297
static const std::string & systemRepoAlias()
Reserved system repository alias @System .
Definition PoolImpl.cc:100
CPool * _pool
sat-pool.
Definition PoolImpl.h:356
void setRepoInfo(RepoIdType id_r, const RepoInfo &info_r)
Also adjust repo priority and subpriority accordingly.
Definition PoolImpl.cc:430
void setDirty(const char *a1=0, const char *a2=0, const char *a3=0)
Invalidate housekeeping data (e.g.
Definition PoolImpl.cc:247
void depSetDirty(const char *a1=0, const char *a2=0, const char *a3=0)
Invalidate housekeeping data (e.g.
Definition PoolImpl.cc:286
static Modalias & instance()
Singleton access.
Definition Modalias.cc:223
std::map< std::string, std::string > read(const Pathname &_path)
Read sysconfig file path_r and return (key,valye) pairs.
Definition sysconfig.cc:34
int LIBSOLV_DEBUGMASK()
Definition PoolImpl.cc:59
static const IdType namespaceLanguage(20)
static const IdType solvablePrereqMarker(15)
Internal ids satlib includes in dependencies.
static void _getLocaleDeps(const Capability &cap_r, LocaleSet &store_r)
Definition PoolImpl.cc:569
static const IdType solvableFileMarker(16)
static const IdType emptyId(1)
static const IdType namespaceModalias(18)
static const IdType namespaceFilesystem(21)
::s_Repo CRepo
Wrapped libsolv C data type exposed as backdoor.
Definition PoolMember.h:63
static const IdType noId(0)
const Pathname & sysconfigStoragePath()
Definition PoolImpl.cc:106
int IdType
Generic Id type.
Definition PoolMember.h:104
::s_Pool CPool
Wrapped libsolv C data type exposed as backdoor.
Definition PoolMember.h:61
BOOST_MPL_ASSERT_RELATION(noId,==, STRID_NULL)
static const SolvableIdType systemSolvableId(1)
Id to denote the usually hidden Solvable::systemSolvable.
CRepo * RepoIdType
Id type to connect Repo and sat-repo.
Definition PoolMember.h:133
static void logSat(CPool *, void *data, int type, const char *logString)
Definition PoolImpl.cc:114
std::string hexdecode(const C_Str &str_r)
Decode hexencoded XX sequences.
Definition String.cc:146
bool hasPrefix(const C_Str &str_r, const C_Str &prefix_r)
Return whether str_r has prefix prefix_r.
Definition String.h:1026
unsigned split(const C_Str &line_r, TOutputIterator result_r, const C_Str &sepchars_r=" \t", const Trim trim_r=NO_TRIM)
Split line_r into words.
Definition String.h:531
Easy-to use interface to the ZYPP dependency resolver.
std::ostream & dumpRangeLine(std::ostream &str, TIterator begin, TIterator end)
Print range defined by iterators (single line style).
Definition LogTools.h:142
std::unordered_set< Locale > LocaleSet
Definition Locale.h:28
std::string asString(const Patch::Category &obj)
Definition Patch.cc:122
int repo_add_helix(::Repo *repo, FILE *fp, int flags)
int testcase_add_testtags(Repo *repo, FILE *fp, int flags)
Track added/removed set items based on an initial set.
Definition SetTracker.h:38
const set_type & current() const
Return the current set.
Definition SetTracker.h:139
bool set(set_type new_r)
Set a new_r set and track changes.
Definition SetTracker.h:78
bool add(const value_type &val_r)
Add an element to the set and track changes.
Definition SetTracker.h:100
bool wasAdded(const key_type &key_r) const
Whether val_r is tracked as added.
Definition SetTracker.h:132
const set_type & added() const
Return the set of added items.
Definition SetTracker.h:142
bool remove(const value_type &val_r)
Remove an element from the set and track changes.
Definition SetTracker.h:114
const set_type & removed() const
Return the set of removed items.
Definition SetTracker.h:145
bool setInitial()
(Re-)Start tracking the current set (discards previously tracked changes).
Definition SetTracker.h:57
static PoolImpl & myPool()
Definition PoolImpl.cc:184
#define for_(IT, BEG, END)
Convenient for-loops using iterator.
Definition Easy.h:28
#define ZYPP_THROW(EXCPT)
Drops a logline and throws the Exception.
Definition Exception.h:429
#define _(MSG)
Definition Gettext.h:37
#define L_ERR(GROUP)
Definition Logger.h:107
#define MIL
Definition Logger.h:96
#define WAR
Definition Logger.h:97
#define L_MIL(GROUP)
Definition Logger.h:105
#define L_DBG(GROUP)
Definition Logger.h:104