libzypp 17.31.0
Product.cc
Go to the documentation of this file.
1/*---------------------------------------------------------------------\
2| ____ _ __ __ ___ |
3| |__ / \ / / . \ . \ |
4| / / \ V /| _/ _/ |
5| / /__ | | | | | | |
6| /_____||_| |_| |_| |
7| |
8\---------------------------------------------------------------------*/
12#include <iostream>
13#include <zypp/base/LogTools.h>
15
16#include <zypp/Product.h>
17#include <zypp/Url.h>
18
19#include <zypp/sat/LookupAttr.h>
22#include <zypp/PoolItem.h>
23
24using std::endl;
25
27namespace zypp
28{
29
31
32 namespace
33 {
34 void fillList( std::list<std::string> & ret_r, sat::Solvable solv_r, sat::SolvAttr attr_r )
35 {
36 sat::LookupAttr query( attr_r, solv_r );
37 for_( it, query.begin(), query.end() )
38 {
39 ret_r.push_back( it.asString() );
40 }
41 }
42 }
43
45 //
46 // METHOD NAME : Product::Product
47 // METHOD TYPE : Ctor
48 //
49 Product::Product( const sat::Solvable & solvable_r )
50 : ResObject( solvable_r )
51 {}
52
54 //
55 // METHOD NAME : Product::~Product
56 // METHOD TYPE : Dtor
57 //
59 {}
60
62
64 {
65 // Look for a provider of 'product(name) = version' of same
66 // architecture and within the same repo.
67 //
68 // Code12: Update repos may have multiple release package versions
69 // providing the same product. Prefer the one matching the buildtime,
70 // as the product buildtime is derived from the -release package.
71 Capability identCap( str::form( "product(%s) = %s", name().c_str(), edition().c_str() ) );
72
73 sat::Solvable found;
74 bool foundBuildTime = false;
75 sat::WhatProvides providers( identCap );
76 for_( it, providers.begin(), providers.end() )
77 {
78 if ( it->repository() == repository() && it->arch() == arch() )
79 {
80 bool fitsBuildtime = ( it->buildtime() == buildtime() );
81 if ( found )
82 {
83 bool lowerEdition = ( it->edition() <= found.edition() );
84 if ( ( foundBuildTime && ( !fitsBuildtime || lowerEdition ) )
85 || ( !foundBuildTime && ( !fitsBuildtime && lowerEdition ) ) )
86 continue;
87 }
88 found = *it;
89 if ( fitsBuildtime )
90 foundBuildTime = true;
91 }
92 }
93
94 if ( ! found && isSystem() )
95 {
96 // bnc#784900: for installed products check whether the file is owned by
97 // some package. If so, ust this as buddy.
99 std::string refFile( referenceFilename() ); // the basename only!
100 if ( ! refFile.empty() )
101 {
102 StrMatcher matcher( "/etc/products.d/"+refFile, Match::STRING | Match::FILES );
103 q.setStrMatcher( matcher );
104 if ( ! q.empty() )
105 found = q.begin().inSolvable();
106 }
107 else
108 INT << "Product referenceFilename unexpectedly empty!" << endl;
109 }
110
111 if ( ! found )
112 WAR << *this << ": no reference package found: " << identCap << endl;
113 return found;
114 }
115
116 std::string Product::referenceFilename() const
118
120 {
121 std::vector<constPtr> ret;
122 // By now we simply collect what is obsoleted by the Product,
123 // or by the products buddy (release-package).
124
125 // Check our own dependencies. We should not have any,
126 // but just to be shure.
127 sat::WhatObsoletes obsoleting( satSolvable() );
128 for_( it, obsoleting.begin(), obsoleting.end() )
129 {
130 if ( it->isKind( ResKind::product ) )
131 ret.push_back( make<Product>( *it ) );
132 }
133
134 // If we have a buddy, we check what product buddies the
135 // buddy replaces.
136 obsoleting = sat::WhatObsoletes( poolItem().buddy() );
137 for_( it, obsoleting.poolItemBegin(), obsoleting.poolItemEnd() )
138 {
139 if ( (*it).buddy().isKind( ResKind::product ) )
140 ret.push_back( make<Product>( (*it).buddy() ) );
141 }
142 return ret;
143 }
144
146 { return poolItem().buddy().valuesOfNamespace( "weakremover" ); }
147
148 std::string Product::productLine() const
150
152
153 std::string Product::shortName() const
154 {
156 if ( ret.empty() ) ret = name();
157 return ret;
158
159 }
160
161 std::string Product::flavor() const
162 {
163 // Look for a provider of 'product_flavor(name) = version'
164 // within the same repo. Unlike the reference package, we
165 // can be relaxed and ignore the architecture.
166 Capability identCap( str::form( "product_flavor(%s) = %s", name().c_str(), edition().c_str() ) );
167
168 sat::WhatProvides providers( identCap );
169 for_( it, providers.begin(), providers.end() )
170 {
171 if ( it->repository() == repository() )
172 {
173 // Got the package now try to get the provided 'flavor(...)'
174 Capabilities provides( it->provides() );
175 for_( cap, provides.begin(), provides.end() )
176 {
177 std::string capstr( cap->asString() );
178 if ( str::hasPrefix( capstr, "flavor(" ) )
179 {
180 capstr = str::stripPrefix( capstr, "flavor(" );
181 capstr.erase( capstr.size()-1 ); // trailing ')'
182 return capstr;
183 }
184 }
185 }
186 }
187 return std::string();
188 }
189
190 std::string Product::type() const
192
193 std::list<std::string> Product::flags() const
194 {
195 std::list<std::string> ret;
196 fillList( ret, satSolvable(), sat::SolvAttr::productFlags );
197 return ret;
198 }
199
202
204 { return( lookupNumAttribute( sat::SolvAttr::productEndOfLife, -1 ) != (unsigned long long)(-1) ); }
205
206 bool Product::hasEndOfLife( Date & value ) const
207 {
209 if ( res == -1 )
210 return false;
211 // else:
212 value = res;
213 return true;
214 }
215
216 std::vector<Repository::ContentIdentifier> Product::updateContentIdentifier() const
217 {
218 std::vector<Repository::ContentIdentifier> ret;
220 if ( ! q.empty() )
221 {
222 ret.reserve( 2 );
223 for_( it, q.begin(), q.end() )
224 ret.push_back( it.asString() );
225 }
226 return ret;
227 }
228
230 {
232 for_( it, q.begin(), q.end() )
233 {
234 if ( it.asString() == cident_r )
235 return true;
236 }
237 return false;
238 }
239
241 { return isSystem() && lookupStrAttribute( sat::SolvAttr::productType ) == "base"; }
242
243 std::string Product::registerTarget() const
245
246 std::string Product::registerRelease() const
248
249 std::string Product::registerFlavor() const
251
253
254 Product::UrlList Product::urls( const std::string & key_r ) const
255 {
256 UrlList ret;
257
260
261 sat::LookupAttr::iterator url_it(url.begin());
262 sat::LookupAttr::iterator url_type_it(url_type.begin());
263
264 for (;url_it != url.end(); ++url_it, ++url_type_it)
265 {
266 /* safety checks, shouldn't happen (tm) */
267 if (url_type_it == url_type.end())
268 {
269 ERR << *this << " : The thing that should not happen, happened." << endl;
270 break;
271 }
272
273 if ( url_type_it.asString() == key_r )
274 {
275 ret._list.push_back(url_it.asString());
276 }
277 } /* while (attribute array) */
278
279 return ret;
280 }
281
282 Product::UrlList Product::releaseNotesUrls() const { return urls( "releasenotes" ); }
283 Product::UrlList Product::registerUrls() const { return urls( "register" ); }
284 Product::UrlList Product::smoltUrls() const { return urls( "smolt" ); }
285 Product::UrlList Product::updateUrls() const { return urls( "update" ); }
286 Product::UrlList Product::extraUrls() const { return urls( "extra" ); }
287 Product::UrlList Product::optionalUrls() const { return urls( "optional" ); }
288
289 std::ostream & operator<<( std::ostream & str, const Product::UrlList & obj )
290 { return dumpRange( str << obj.key() << ' ', obj.begin(), obj.end() ); }
291
293} // namespace zypp
Container of Capability (currently read only).
Definition: Capabilities.h:36
const_iterator begin() const
Iterator pointing to the first Capability.
Definition: Capabilities.h:169
const_iterator end() const
Iterator pointing behind the last Capability.
Definition: Capabilities.h:172
A sat capability.
Definition: Capability.h:60
Store and operate on date (time_t).
Definition: Date.h:33
@ STRING
Excat matching.
Definition: StrMatcher.h:43
static const Match FILES
LookupAttr: match full path when matching in filelists, otherwise just the basenames.
Definition: StrMatcher.h:75
sat::Solvable buddy() const
Return the buddy we share our status object with.
Definition: PoolItem.cc:214
Helper to iterate a products URL lists.
Definition: Product.h:209
const_iterator end() const
Definition: Product.h:228
std::string key() const
The key used to retrieve this list (for debug)
Definition: Product.h:237
const_iterator begin() const
Definition: Product.h:225
Product interface.
Definition: Product.h:33
ReplacedProducts replacedProducts() const
Array of installed Products that would be replaced by installing this one.
Definition: Product.cc:119
std::list< std::string > flags() const
The product flags.
Definition: Product.cc:193
UrlList extraUrls() const
Additional software for the product They are complementary, not alternatives.
Definition: Product.cc:286
std::vector< constPtr > ReplacedProducts
Definition: Product.h:73
std::string flavor() const
The product flavor (LiveCD Demo, FTP edition,...).
Definition: Product.cc:161
bool isTargetDistribution() const
This is the installed product that is also targeted by the /etc/products.d/baseproduct symlink.
Definition: Product.cc:240
UrlList releaseNotesUrls() const
The URL to download the release notes for this product.
Definition: Product.cc:282
std::string shortName() const
Untranslated short name like SLES 10 (fallback: name)
Definition: Product.cc:153
std::string referenceFilename() const
For installed products the name of the corresponding /etc/products.d entry.
Definition: Product.cc:116
UrlList registerUrls() const
The URL for registration.
Definition: Product.cc:283
std::string registerTarget() const
This is register.target attribute of a product.
Definition: Product.cc:243
Product(const sat::Solvable &solvable_r)
Ctor.
Definition: Product.cc:49
bool hasEndOfLife() const
Return whether an EndOfLife value is actually defined in the metadata.
Definition: Product.cc:203
CapabilitySet droplist() const
List of packages included in older versions of this product and now dropped.
Definition: Product.cc:145
bool hasUpdateContentIdentifier(const Repository::ContentIdentifier &cident_r) const
Whether cident_r is listed as required update repository.
Definition: Product.cc:229
Date endOfLife() const
The date when this Product goes out of support as indicated by its medadata.
Definition: Product.cc:200
UrlList updateUrls() const
Online updates for the product.
Definition: Product.cc:285
sat::Solvable referencePackage() const
The reference package providing the product metadata, if such a package exists.
Definition: Product.cc:63
virtual ~Product()
Dtor.
Definition: Product.cc:58
UrlList urls(const std::string &key_r) const
Retrieve URLs flagged with key_r for this product.
Definition: Product.cc:254
std::string type() const
Get the product type Well, in an ideal world there is only one base product.
Definition: Product.cc:190
std::vector< Repository::ContentIdentifier > updateContentIdentifier() const
ContentIdentifier of required update repositories.
Definition: Product.cc:216
std::string registerFlavor() const
This is register.flavor attribute of a product.
Definition: Product.cc:249
std::string registerRelease() const
This is register.release attribute of an installed product.
Definition: Product.cc:246
UrlList smoltUrls() const
The URL for SMOLT.
Definition: Product.cc:284
std::string productLine() const
Vendor specific string denoting the product line.
Definition: Product.cc:148
UrlList optionalUrls() const
Optional software for the product.
Definition: Product.cc:287
std::string ContentIdentifier
Definition: Repository.h:49
static const ResKind product
Definition: ResKind.h:43
Base for resolvable objects.
Definition: ResObject.h:38
PoolItem poolItem() const
Access the corresponding PoolItem.
Definition: Resolvable.cc:28
String matching (STRING|SUBSTRING|GLOB|REGEX).
Definition: StrMatcher.h:298
std::string asString() const
This is an overloaded member function, provided for convenience. It differs from the above function o...
Definition: LookupAttr.cc:610
Solvable inSolvable() const
The current Solvable.
Definition: LookupAttr.cc:354
Lightweight attribute value lookup.
Definition: LookupAttr.h:108
iterator end() const
Iterator behind the end of query results.
Definition: LookupAttr.cc:239
bool empty() const
Whether the query is empty.
Definition: LookupAttr.cc:242
void setStrMatcher(const StrMatcher &matcher_r)
Set the pattern to match.
Definition: LookupAttr.cc:205
iterator begin() const
Iterator to the begin of query results.
Definition: LookupAttr.cc:236
Solvable attribute keys.
Definition: SolvAttr.h:41
static const SolvAttr productRegisterRelease
Definition: SolvAttr.h:152
static const SolvAttr filelist
Definition: SolvAttr.h:99
static const SolvAttr productUpdatesRepoid
Definition: SolvAttr.h:157
static const SolvAttr productProductLine
Definition: SolvAttr.h:144
static const SolvAttr productReferenceFile
Definition: SolvAttr.h:143
static const SolvAttr productRegisterFlavor
Definition: SolvAttr.h:153
static const SolvAttr productType
Definition: SolvAttr.h:148
static const SolvAttr productRegisterTarget
Definition: SolvAttr.h:151
static const SolvAttr productUrl
Definition: SolvAttr.h:154
static const SolvAttr productUpdates
array of repoids, hopefully label s too
Definition: SolvAttr.h:156
static const SolvAttr productEndOfLife
Definition: SolvAttr.h:150
static const SolvAttr productFlags
Definition: SolvAttr.h:149
static const SolvAttr productShortlabel
Definition: SolvAttr.h:145
static const SolvAttr productUrlType
Definition: SolvAttr.h:155
PoolItem_iterator poolItemEnd() const
PoolItem_iterator poolItemBegin() const
A Solvable object within the sat Pool.
Definition: Solvable.h:54
Edition edition() const
The edition (version-release).
Definition: Solvable.cc:337
CapabilitySet valuesOfNamespace(const std::string &namespace_r) const
Return 'value[ op edition]' for namespaced provides 'namespace(value)[ op edition]'.
Definition: Solvable.cc:547
Container of installed Solvable which would be obsoleted by the Solvable passed to the ctor.
Definition: WhatObsoletes.h:38
const_iterator end() const
Iterator pointing behind the last Solvable.
Definition: WhatObsoletes.h:87
const_iterator begin() const
Iterator pointing to the first Solvable.
Definition: WhatObsoletes.h:83
Container of Solvable providing a Capability (read only).
Definition: WhatProvides.h:89
const_iterator end() const
Iterator pointing behind the last Solvable.
Definition: WhatProvides.h:226
const_iterator begin() const
Iterator pointing to the first Solvable.
String related utilities and Regular expression matching.
bool hasPrefix(const C_Str &str_r, const C_Str &prefix_r)
Return whether str_r has prefix prefix_r.
Definition: String.h:1027
std::string form(const char *format,...) __attribute__((format(printf
Printf style construction of std::string.
Definition: String.cc:36
std::string stripPrefix(const C_Str &str_r, const C_Str &prefix_r)
Strip a prefix_r from str_r and return the resulting string.
Definition: String.h:1034
Easy-to use interface to the ZYPP dependency resolver.
Definition: CodePitfalls.doc:2
std::unordered_set< Capability > CapabilitySet
Definition: Capability.h:33
std::ostream & dumpRange(std::ostream &str, TIterator begin, TIterator end, const std::string &intro="{", const std::string &pfx="\n ", const std::string &sep="\n ", const std::string &sfx="\n", const std::string &extro="}")
Print range defined by iterators (multiline style).
Definition: LogTools.h:91
std::ostream & operator<<(std::ostream &str, const SerialNumber &obj)
Definition: SerialNumber.cc:52
IMPL_PTR_TYPE(Application)
std::string lookupStrAttribute(const SolvAttr &attr) const
Definition: SolvableType.h:140
Solvable satSolvable() const
Return the corresponding sat::Solvable.
Definition: SolvableType.h:57
unsigned long long lookupNumAttribute(const SolvAttr &attr) const
Definition: SolvableType.h:144
#define for_(IT, BEG, END)
Convenient for-loops using iterator.
Definition: Easy.h:28
#define ERR
Definition: Logger.h:98
#define WAR
Definition: Logger.h:97
#define INT
Definition: Logger.h:100