libzypp 17.31.0
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.
75 BOOST_MPL_ASSERT_RELATION( noId, ==, STRID_NULL );
77
80
81 BOOST_MPL_ASSERT_RELATION( solvablePrereqMarker, ==, SOLVABLE_PREREQMARKER );
82 BOOST_MPL_ASSERT_RELATION( solvableFileMarker, ==, SOLVABLE_FILEMARKER );
83
93
94 BOOST_MPL_ASSERT_RELATION( namespaceModalias, ==, NAMESPACE_MODALIAS );
95 BOOST_MPL_ASSERT_RELATION( namespaceLanguage, ==, NAMESPACE_LANGUAGE );
96 BOOST_MPL_ASSERT_RELATION( namespaceFilesystem, ==, NAMESPACE_FILESYSTEM );
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 {
149 case NAMESPACE_LANGUAGE:
150 {
151 const TrackedLocaleIds & localeIds( reinterpret_cast<PoolImpl*>(data)->trackedLocaleIds() );
152 return localeIds.contains( IdString(rhs) ) ? RET_systemProperty : RET_unsupported;
153 }
154 break;
155
156 case NAMESPACE_MODALIAS:
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() ) )
161 ? RET_systemProperty
162 : RET_unsupported;
163 }
164 break;
165
166 case NAMESPACE_FILESYSTEM:
167 {
168 const std::set<std::string> & requiredFilesystems( reinterpret_cast<PoolImpl*>(data)->requiredFilesystems() );
169 return requiredFilesystems.find( IdString(rhs).asString() ) != requiredFilesystems.end() ? RET_systemProperty : RET_unsupported;
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:
300 static WatchFile sysconfigFile( sysconfigStoragePath(), WatchFile::NO_INIT );
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 {
339 setDirty(__FUNCTION__, repo_r->name );
340 if ( isSystemRepo( repo_r ) )
342 eraseRepoInfo( 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
353 int PoolImpl::_addSolv( CRepo * repo_r, FILE * file_r )
354 {
355 setDirty(__FUNCTION__, repo_r->name );
356 int ret = ::repo_add_solv( repo_r, file_r, 0 );
357 if ( ret == 0 )
358 _postRepoAdd( repo_r );
359 return ret;
360 }
361
362 int PoolImpl::_addHelix( CRepo * repo_r, FILE * file_r )
363 {
364 setDirty(__FUNCTION__, repo_r->name );
365 int ret = ::repo_add_helix( repo_r, file_r, 0 );
366 if ( ret == 0 )
367 _postRepoAdd( repo_r );
368 return 0;
369 }
370
371 int PoolImpl::_addTesttags(CRepo *repo_r, FILE *file_r)
372 {
373 setDirty(__FUNCTION__, repo_r->name );
374 int ret = ::testcase_add_testtags( repo_r, file_r, 0 );
375 if ( ret == 0 )
376 _postRepoAdd( repo_r );
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
396 detail::IdType blockBegin = 0;
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 {
426 setDirty(__FUNCTION__, repo_r->name );
427 return ::repo_add_solvable_block( repo_r, count_r );
428 }
429
430 void PoolImpl::setRepoInfo( RepoIdType id_r, const RepoInfo & info_r )
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.
447 int mediaPriority( media::MediaPriority( info_r.url() ) );
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 }
457 _repoinfos[id_r] = info_r;
458 }
459
461
462 void PoolImpl::setTextLocale( const Locale & locale_r )
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 {
489 if ( _requestedLocalesTracker.setInitial( locales_r ) )
490 {
491 localeSetDirty( "initRequestedLocales" );
492 MIL << "Init RequestedLocales: " << _requestedLocalesTracker << " =" << locales_r << endl;
493 }
494 }
495
496 void PoolImpl::setRequestedLocales( const LocaleSet & locales_r )
497 {
498 if ( _requestedLocalesTracker.set( locales_r ) )
499 {
500 localeSetDirty( "setRequestedLocales" );
501 MIL << "New RequestedLocales: " << _requestedLocalesTracker << " =" << locales_r << endl;
502 }
503 }
504
505 bool PoolImpl::addRequestedLocale( const Locale & locale_r )
506 {
507 bool done = _requestedLocalesTracker.add( locale_r );
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
516 bool PoolImpl::eraseRequestedLocale( const Locale & locale_r )
517 {
518 bool done = _requestedLocalesTracker.remove( locale_r );
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
569 static void _getLocaleDeps( const Capability & cap_r, LocaleSet & store_r )
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 );
602 LocaleSet & localeSet( *_availableLocalesPtr );
603
604 for ( const Solvable & pi : Pool::instance().solvables() )
605 {
606 for ( const Capability & cap : pi.supplements() )
607 {
608 _getLocaleDeps( cap, localeSet );
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 )
631 multiversionList.insert( solv );
632 }
633
635 MIL << "Multiversion install " << spec << ": " << (nsize-size) << " matches" << endl;
636 size = nsize;
637 }
638 }
639
641 { _multiversionListPtr.reset(); }
642
644 {
645 if ( ! _multiversionListPtr )
647 return *_multiversionListPtr;
648 }
649
650 bool PoolImpl::isMultiversion( const Solvable & solv_r ) const
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
std::set< Arch, CompareByGT< Arch > > CompatSet
Reversed arch order, best Arch first.
Definition: Arch.h:117
static CompatSet compatSet(const Arch &targetArch_r)
Return a set of all Arch's compatibleWith a targetArch_r.
Definition: Arch.cc:558
Helper providing more detailed information about a Capability.
Definition: Capability.h:299
Capability rhs() const
Definition: Capability.h:361
Capability lhs() const
Definition: Capability.h:359
Kind kind() const
Definition: Capability.h:341
CapRel capRel() const
Definition: Capability.h:360
@ CAP_WITHOUT
without
Definition: Capability.h:323
@ CAP_ARCH
Used internally.
Definition: Capability.h:326
@ CAP_UNLESS
unless
Definition: Capability.h:319
A sat capability.
Definition: Capability.h:60
sat::detail::IdType id() const
Expert backdoor.
Definition: Capability.h:253
Base class for Exception.
Definition: Exception.h:146
Access to the sat-pools string space.
Definition: IdString.h:43
'Language[_Country]' codes.
Definition: Locale.h:50
Locale fallback() const
Return the fallback locale for this locale, if no fallback exists the empty Locale::noCode.
Definition: Locale.cc:208
std::string code() const
Return the locale code asString.
Definition: Locale.h:88
What is known about a repository.
Definition: RepoInfo.h:72
Url url() const
Pars pro toto: The first repository url.
Definition: RepoInfo.h:131
unsigned priority() const
Repository priority for solver.
Definition: RepoInfo.cc:390
bool remember(unsigned serial_r) const
Return isDirty, storing serial_r as new value.
Definition: SerialNumber.h:160
Remember a files attributes to detect content changes.
Definition: watchfile.h:50
bool hasChanged()
Definition: watchfile.h:80
Locale textLocale() const
The locale for translated texts zypp uses.
Definition: ZConfig.cc:899
static ZConfig & instance()
Singleton ctor.
Definition: ZConfig.cc:823
Derive a numeric priority from Url scheme according to zypp.conf(download.media_preference).
Definition: MediaPriority.h:44
std::string alias() const
unique identifier for this source.
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
size_type size() const
Size of the set.
Definition: SolvableSet.h:63
Container::size_type size_type
Definition: SolvableSet.h:42
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).
Definition: WhatProvides.h:89
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
PoolImpl()
Default ctor.
Definition: PoolImpl.cc:195
void depSetDirty(const char *a1=0, const char *a2=0, const char *a3=0)
Invalidate housekeeping data (e.g.
Definition: PoolImpl.cc:286
bool query(IdString cap_r) const
Checks if a device on the system matches a modalias pattern.
Definition: Modalias.h:69
static Modalias & instance()
Singleton access.
Definition: Modalias.cc:219
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)
static const IdType noId(0)
static const SolvableIdType noSolvableId(0)
Id to denote Solvable::noSolvable.
const Pathname & sysconfigStoragePath()
Definition: PoolImpl.cc:106
BOOST_MPL_ASSERT_RELATION(noId,==, STRID_NULL)
::s_Repo CRepo
Wrapped libsolv C data type exposed as backdoor.
Definition: PoolMember.h:63
int IdType
Generic Id type.
Definition: PoolMember.h:104
::s_Solvable CSolvable
Wrapped libsolv C data type exposed as backdoor.
Definition: PoolMember.h:64
::s_Pool CPool
Wrapped libsolv C data type exposed as backdoor.
Definition: PoolMember.h:61
unsigned SolvableIdType
Id type to connect Solvable and sat-solvable.
Definition: PoolMember.h:125
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:145
bool hasPrefix(const C_Str &str_r, const C_Str &prefix_r)
Return whether str_r has prefix prefix_r.
Definition: String.h:1027
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.
Definition: CodePitfalls.doc:2
std::ostream & dumpRangeLine(std::ostream &str, TIterator begin, TIterator end)
Print range defined by iterators (single line style).
Definition: LogTools.h:114
std::unordered_set< Locale > LocaleSet
Definition: Locale.h:27
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
bool contains(const key_type &key_r) const
Whether val_r is in the set.
Definition: SetTracker.h:129
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:428
#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