libzypp  13.10.6
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"
14 #include "zypp/base/StrMatcher.h"
15 
16 #include "zypp/Product.h"
17 #include "zypp/Url.h"
18 
19 #include "zypp/sat/LookupAttr.h"
20 #include "zypp/sat/WhatProvides.h"
21 #include "zypp/sat/WhatObsoletes.h"
22 #include "zypp/PoolItem.h"
23 
24 using std::endl;
25 
27 namespace zypp
28 {
29 
30  IMPL_PTR_TYPE(Product);
31 
32  namespace
33  {
34  void fillList( std::list<Url> & 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  try // ignore malformed urls
40  {
41  ret_r.push_back( Url( it.asString() ) );
42  }
43  catch( const url::UrlException & )
44  {}
45  }
46  }
47 
48  void fillList( std::list<std::string> & ret_r, sat::Solvable solv_r, sat::SolvAttr attr_r )
49  {
50  sat::LookupAttr query( attr_r, solv_r );
51  for_( it, query.begin(), query.end() )
52  {
53  ret_r.push_back( it.asString() );
54  }
55  }
56  }
57 
59  //
60  // METHOD NAME : Product::Product
61  // METHOD TYPE : Ctor
62  //
63  Product::Product( const sat::Solvable & solvable_r )
64  : ResObject( solvable_r )
65  {}
66 
68  //
69  // METHOD NAME : Product::~Product
70  // METHOD TYPE : Dtor
71  //
73  {}
74 
76 
78  {
79  // Look for a provider of 'product(name) = version' of same
80  // architecture and within the same repo.
81  //
82  // bnc #497696: Update repos may have multiple release package versions
83  // providing the same product. As a workaround we link to the one with
84  // the highest version.
85  Capability identCap( str::form( "product(%s) = %s", name().c_str(), edition().c_str() ) );
86 
87  sat::Solvable found;
88  sat::WhatProvides providers( identCap );
89  for_( it, providers.begin(), providers.end() )
90  {
91  if ( it->repository() == repository()
92  && it->arch() == arch() )
93  {
94  if ( ! found || found.edition() < it->edition() )
95  found = *it;
96  }
97  }
98 
99  if ( ! found && isSystem() )
100  {
101  // bnc#784900: for installed products check whether the file is owned by
102  // some package. If so, ust this as buddy.
104  std::string refFile( referenceFilename() );
105  if ( ! refFile.empty() )
106  {
107  StrMatcher matcher( referenceFilename() );
108  q.setStrMatcher( matcher );
109  if ( ! q.empty() )
110  found = q.begin().inSolvable();
111  }
112  else
113  INT << "Product referenceFilename unexpectedly empty!" << endl;
114  }
115 
116  if ( ! found )
117  WAR << *this << ": no reference package found: " << identCap << endl;
118  return found;
119  }
120 
121  std::string Product::referenceFilename() const
123 
125  {
126  std::vector<constPtr> ret;
127  // By now we simply collect what is obsoleted by the Product,
128  // or by the products buddy (release-package).
129 
130  // Check our own dependencies. We should not have any,
131  // but just to be shure.
132  sat::WhatObsoletes obsoleting( satSolvable() );
133  for_( it, obsoleting.begin(), obsoleting.end() )
134  {
135  if ( it->isKind( ResKind::product ) )
136  ret.push_back( make<Product>( *it ) );
137  }
138 
139  // If we have a buddy, we check what product buddies the
140  // buddy replaces.
141  obsoleting = sat::WhatObsoletes( poolItem().buddy() );
142  for_( it, obsoleting.poolItemBegin(), obsoleting.poolItemEnd() )
143  {
144  if ( (*it).buddy().isKind( ResKind::product ) )
145  ret.push_back( make<Product>( (*it).buddy() ) );
146  }
147  return ret;
148  }
149 
151  { return poolItem().buddy().valuesOfNamespace( "weakremover" ); }
152 
153  std::string Product::productLine() const
155 
157 
158  std::string Product::shortName() const
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 
201  { return isSystem() && lookupStrAttribute( sat::SolvAttr::productType ) == "base"; }
202 
203  std::string Product::registerTarget() const
205 
206  std::string Product::registerRelease() const
208 
210 
211  Product::UrlList Product::urls( const std::string & key_r ) const
212  {
213  UrlList ret;
214 
217 
218  sat::LookupAttr::iterator url_it(url.begin());
219  sat::LookupAttr::iterator url_type_it(url_type.begin());
220 
221  for (;url_it != url.end(); ++url_it, ++url_type_it)
222  {
223  /* safety checks, shouldn't happen (tm) */
224  if (url_type_it == url_type.end())
225  {
226  ERR << *this << " : The thing that should not happen, happened." << endl;
227  break;
228  }
229 
230  if ( url_type_it.asString() == key_r )
231  {
232  ret._list.push_back(url_it.asString());
233  }
234  } /* while (attribute array) */
235 
236  return ret;
237  }
238 
239  Product::UrlList Product::releaseNotesUrls() const { return urls( "releasenotes" ); }
240  Product::UrlList Product::registerUrls() const { return urls( "register" ); }
241  Product::UrlList Product::smoltUrls() const { return urls( "smolt" ); }
242  Product::UrlList Product::updateUrls() const { return urls( "update" ); }
243  Product::UrlList Product::extraUrls() const { return urls( "extra" ); }
244  Product::UrlList Product::optionalUrls() const { return urls( "optional" ); }
245 
246  std::ostream & operator<<( std::ostream & str, const Product::UrlList & obj )
247  { return dumpRange( str << obj.key() << ' ', obj.begin(), obj.end() ); }
248 
250 } // namespace zypp
static const SolvAttr productFlags
Definition: SolvAttr.h:148
Product(const sat::Solvable &solvable_r)
Ctor.
Definition: Product.cc:63
bool isSystem() const
Whether this represents an installed solvable.
Definition: Resolvable.h:53
const_iterator end() const
Definition: Product.h:188
A Solvable object within the sat Pool.
Definition: Solvable.h:55
Container of Solvable providing a Capability (read only).
Definition: WhatProvides.h:87
UrlList releaseNotesUrls() const
The URL to download the release notes for this product.
Definition: Product.cc:239
Container of Capability (currently read only).
Definition: Capabilities.h:35
Helper to iterate a products URL lists.
Definition: Product.h:168
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:832
Repository repository() const
Definition: ResObject.h:169
String matching (STRING|SUBSTRING|GLOB|REGEX).
Definition: StrMatcher.h:297
Lightweight attribute value lookup.
Definition: LookupAttr.h:111
std::string key() const
The key used to retrieve this list (for debug)
Definition: Product.h:197
Arch arch() const
Definition: Resolvable.h:79
#define INT
Definition: Logger.h:51
std::string lookupStrAttribute(const SolvAttr &attr) const
returns the string attribute value for attr or an empty string if it does not exists.
Definition: Solvable.cc:171
Capabilities provides() const
Definition: Resolvable.h:97
static const SolvAttr productRegisterRelease
Definition: SolvAttr.h:150
UrlList registerUrls() const
The URL for registration.
Definition: Product.cc:240
UrlList optionalUrls() const
Optional software for the product.
Definition: Product.cc:244
static const SolvAttr productProductLine
Definition: SolvAttr.h:143
static const SolvAttr productUrlType
Definition: SolvAttr.h:152
const_iterator begin() const
Definition: Product.h:185
#define for_(IT, BEG, END)
Convenient for-loops using iterator.
Definition: Easy.h:27
UrlList extraUrls() const
Additional software for the product They are complementary, not alternatives.
Definition: Product.cc:243
CapabilitySet valuesOfNamespace(const std::string &namespace_r) const
Return &#39;value[ op edition]&#39; for namespaced provides &#39;namespace(value)[ op edition]&#39;.
Definition: Solvable.cc:487
std::string registerRelease() const
This is register.release attribute of an installed product.
Definition: Product.cc:206
std::tr1::unordered_set< Capability > CapabilitySet
Definition: Capability.h:33
#define ERR
Definition: Logger.h:49
static const SolvAttr productRegisterTarget
Definition: SolvAttr.h:149
std::string name() const
Definition: Resolvable.h:73
std::ostream & dumpRange(std::ostream &str, _Iterator begin, _Iterator 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
iterator end() const
Iterator behind the end of query results.
Definition: LookupAttr.cc:239
const_iterator begin() const
Iterator pointing to the first Solvable.
std::ostream & operator<<(std::ostream &str, const Exception &obj)
Definition: Exception.cc:120
std::string flavor() const
The product flavor (LiveCD Demo, FTP edition,...).
Definition: Product.cc:161
const_iterator end() const
Iterator pointing behind the last Solvable.
Definition: WhatProvides.h:226
PoolItem_iterator poolItemEnd() const
Solvable inSolvable() const
The current Solvable.
Definition: LookupAttr.cc:354
PoolItem poolItem() const
Access the corresponding PoolItem.
Definition: Resolvable.cc:44
const sat::Solvable & satSolvable() const
Access the corresponding ::Solvable.
Definition: Resolvable.h:133
#define WAR
Definition: Logger.h:48
const_iterator begin() const
Iterator pointing to the first Solvable.
Definition: WhatObsoletes.h:83
static const SolvAttr productType
Definition: SolvAttr.h:147
PoolItem_iterator poolItemBegin() const
void setStrMatcher(const StrMatcher &matcher_r)
Set the pattern to match.
Definition: LookupAttr.cc:205
sat::Solvable referencePackage() const
The reference package providing the product metadata, if such a package exists.
Definition: Product.cc:77
zypp::Url url
Definition: MediaCurl.cc:193
Interface base for resolvable objects (common data).
Definition: ResObject.h:44
std::string type() const
Get the product type Well, in an ideal world there is only one base product.
Definition: Product.cc:190
Container of installed Solvable which would be obsoleted by the Solvable passed to the ctor...
Definition: WhatObsoletes.h:36
UrlList updateUrls() const
Online updates for the product.
Definition: Product.cc:242
static const SolvAttr productUrl
Definition: SolvAttr.h:151
ReplacedProducts replacedProducts() const
Array of installed Products that would be replaced by installing this one.
Definition: Product.cc:124
bool empty() const
Whether the query is empty.
Definition: LookupAttr.cc:242
std::string form(const char *format,...)
Printf style construction of std::string.
Definition: String.cc:34
const_iterator end() const
Iterator pointing behind the last Capability.
Definition: Capabilities.h:165
std::vector< constPtr > ReplacedProducts
Definition: Product.h:73
std::string shortName() const
Untranslated short name like SLES 10
Definition: Product.cc:158
CapabilitySet droplist() const
List of packages included in older versions of this product and now dropped.
Definition: Product.cc:150
bool isTargetDistribution() const
This is the installed product that is also targeted by the /etc/products.d/baseproduct symlink...
Definition: Product.cc:200
sat::Solvable buddy() const
Return the buddy we share our status object with.
Definition: PoolItem.cc:247
std::string productLine() const
Vendor specific string denoting the product line.
Definition: Product.cc:153
A sat capability.
Definition: Capability.h:59
static const SolvAttr filelist
Definition: SolvAttr.h:99
std::string referenceFilename() const
For installed products the name of the coddesponding /etc/products.d entry.
Definition: Product.cc:121
std::list< std::string > flags() const
The product flags.
Definition: Product.cc:193
Edition edition() const
Definition: Resolvable.h:76
IMPL_PTR_TYPE(KeyRing)
virtual ~Product()
Dtor.
Definition: Product.cc:72
std::string registerTarget() const
This is register.target attribute of an installed product.
Definition: Product.cc:203
static const ResKind product
Definition: ResKind.h:46
static const SolvAttr productReferenceFile
Definition: SolvAttr.h:142
bool hasPrefix(const C_Str &str_r, const C_Str &prefix_r)
Return whether str_r has prefix prefix_r.
Definition: String.h:828
UrlList urls(const std::string &key_r) const
Rerieve urls flagged with key_r for this product.
Definition: Product.cc:211
const_iterator begin() const
Iterator pointing to the first Capability.
Definition: Capabilities.h:162
Edition edition() const
Definition: Solvable.cc:372
static const SolvAttr productShortlabel
Definition: SolvAttr.h:144
const_iterator end() const
Iterator pointing behind the last Solvable.
Definition: WhatObsoletes.h:87
iterator begin() const
Iterator to the begin of query results.
Definition: LookupAttr.cc:236
UrlList smoltUrls() const
The URL for SMOLT.
Definition: Product.cc:241