libzypp  17.30.0
Patch.cc
Go to the documentation of this file.
1 /*---------------------------------------------------------------------\
2 | ____ _ __ __ ___ |
3 | |__ / \ / / . \ . \ |
4 | / / \ V /| _/ _/ |
5 | / /__ | | | | | | |
6 | /_____||_| |_| |_| |
7 | |
8 \---------------------------------------------------------------------*/
12 #include <iostream>
13 
14 #include <zypp/base/LogTools.h>
15 #include <zypp/base/String.h>
16 #include <zypp/Patch.h>
17 #include <zypp/sat/WhatProvides.h>
18 
19 using std::endl;
20 
22 namespace zypp
23 {
24 
26 
28  //
29  // METHOD NAME : Patch::Patch
30  // METHOD TYPE : Ctor
31  //
32  Patch::Patch( const sat::Solvable & solvable_r )
33  : ResObject( solvable_r )
34  {}
35 
37  //
38  // METHOD NAME : Patch::~Patch
39  // METHOD TYPE : Dtor
40  //
42  {}
43 
45 
46  std::string Patch::category() const
48 
50  { return categoryEnum( category() ); }
51 
52  bool Patch::isCategory( const std::string & category_r ) const
53  {
54  // bsc#1179847: identify the wellknown categories
55  Category catenum = categoryEnum( category_r );
56  return ( catenum == CAT_OTHER && str::compareCI( category_r, category() ) == 0 )
57  || ( catenum == categoryEnum() );
58  }
59 
60  bool Patch::isCategory( Categories category_r ) const
61  { return category_r.testFlag( categoryEnum() ); }
62 
63  Patch::Category Patch::categoryEnum( const std::string & category_r )
64  {
65  switch ( category_r[0] )
66  {
67  // CAT_YAST
68  case 'y':
69  case 'Y':
70  if ( str::compareCI( category_r, "yast" ) == 0 )
71  return CAT_YAST;
72  break;
73 
74  // CAT_SECURITY
75  case 's':
76  case 'S':
77  if ( str::compareCI( category_r, "security" ) == 0 )
78  return CAT_SECURITY;
79  break;
80 
81  // CAT_RECOMMENDED
82  case 'r':
83  case 'R':
84  if ( str::compareCI( category_r, "recommended" ) == 0 )
85  return CAT_RECOMMENDED;
86  break;
87  case 'b':
88  case 'B':
89  if ( str::compareCI( category_r, "bugfix" ) == 0 ) // rhn
90  return CAT_RECOMMENDED;
91  break;
92 
93  // CAT_OPTIONAL
94  case 'o':
95  case 'O':
96  if ( str::compareCI( category_r, "optional" ) == 0 )
97  return CAT_OPTIONAL;
98  break;
99  case 'f':
100  case 'F':
101  if ( str::compareCI( category_r, "feature" ) == 0 )
102  return CAT_OPTIONAL;
103  break;
104  case 'e':
105  case 'E':
106  if ( str::compareCI( category_r, "enhancement" ) == 0 ) // rhn
107  return CAT_OPTIONAL;
108  break;
109 
110  // CAT_DOCUMENT
111  case 'd':
112  case 'D':
113  if ( str::compareCI( category_r, "document" ) == 0 )
114  return CAT_DOCUMENT;
115  break;
116  }
117  // default:
118  INT << "Unrecognized Patch::Category string '" << category_r << "'" << endl;
119  return CAT_OTHER;
120  }
121 
122  std::string asString( const Patch::Category & obj )
123  {
124  switch ( obj )
125  {
126  case Patch::CAT_OTHER: return std::string( "other" ); break;
127  case Patch::CAT_YAST: return std::string( "yast" ); break;
128  case Patch::CAT_SECURITY: return std::string( "security" ); break;
129  case Patch::CAT_RECOMMENDED: return std::string( "recommended" ); break;
130  case Patch::CAT_OPTIONAL: return std::string( "optional" ); break;
131  case Patch::CAT_DOCUMENT: return std::string( "document" ); break;
132  }
133  // make gcc happy:
134  return std::string( "other" );
135  }
136 
138 
139  std::string Patch::severity() const
141 
143  { return severityFlag( severity() ); }
144 
145  bool Patch::isSeverity( const std::string & severity_r ) const
146  { return( str::compareCI( severity_r, severity() ) == 0 ); }
147 
148  bool Patch::isSeverity( SeverityFlags severity_r ) const
149  { return severity_r.testFlag( severityFlag() ); }
150 
151  Patch::SeverityFlag Patch::severityFlag( const std::string & severity_r )
152  {
153  switch ( severity_r[0] )
154  {
155  case 'l':
156  case 'L':
157  if ( str::compareCI( severity_r, "low" ) == 0 )
158  return SEV_LOW;
159  break;
160 
161  case 'm':
162  case 'M':
163  if ( str::compareCI( severity_r, "moderate" ) == 0 )
164  return SEV_MODERATE;
165  break;
166 
167  case 'i':
168  case 'I':
169  if ( str::compareCI( severity_r, "important" ) == 0 )
170  return SEV_IMPORTANT;
171  break;
172 
173  case 'c':
174  case 'C':
175  if ( str::compareCI( severity_r, "critical" ) == 0 )
176  return SEV_CRITICAL;
177  break;
178 
179  case 'u':
180  case 'U':
181  if ( str::compareCI( severity_r, "unspecified" ) == 0 )
182  return SEV_NONE;
183  break;
184 
185  case '\0':
186  return SEV_NONE;
187  break;
188  }
189  // default:
190  INT << "Unrecognized Patch::Severity string '" << severity_r << "'" << endl;
191  return SEV_OTHER;
192  }
193 
194  std::string asString( const Patch::SeverityFlag & obj )
195  {
196  switch ( obj )
197  {
198  case Patch::SEV_OTHER: return std::string( "unknown" ); break;
199  case Patch::SEV_NONE: return std::string( "unspecified" ); break;
200  case Patch::SEV_LOW: return std::string( "low" ); break;
201  case Patch::SEV_MODERATE: return std::string( "moderate" ); break;
202  case Patch::SEV_IMPORTANT:return std::string( "important" ); break;
203  case Patch::SEV_CRITICAL: return std::string( "critical" ); break;
204  }
205  // make gcc happy:
206  return std::string( "unknown" );
207  }
208 
210  //
211 std::string Patch::message( const Locale & lang_r ) const
212  { return lookupStrAttribute( sat::SolvAttr::message, lang_r ); }
213 
216 
219 
222 
223  Patch::InteractiveFlags Patch::interactiveFlags() const
224  {
225  InteractiveFlags patchFlags (NoFlags);
226  if ( rebootSuggested() )
227  patchFlags |= Reboot;
228 
229  if ( ! message().empty() )
230  patchFlags |= Message;
231 
232  if ( ! licenseToConfirm().empty() )
233  patchFlags |= License;
234 
235  Patch::Contents c( contents() );
236  for_( it, c.begin(), c.end() )
237  {
238  if ( ! makeResObject(*it)->licenseToConfirm().empty() )
239  {
240  patchFlags |= License;
241  break;
242  }
243  }
244  return patchFlags;
245  }
246 
247  bool Patch::interactiveWhenIgnoring( InteractiveFlags flags_r ) const
248  {
249  if ( interactiveFlags() & ( ~flags_r ) )
250  {
251  return true;
252  }
253  else
254  {
255  return false;
256  }
257  }
258 
259  bool Patch::interactive() const
260  {
261  return interactiveWhenIgnoring();
262  }
263 
264  std::string asString( const Patch::InteractiveFlag & obj )
265  {
266  switch ( obj )
267  {
268  case Patch::NoFlags: return ""; break;
269  case Patch::Reboot: return "reboot"; break;
270  case Patch::Message: return "message"; break;
271  case Patch::License: return "license"; break;
272  }
273  return str::hexstring(obj);
274  }
275 
277  {
278  Contents result;
279  // DBG << *this << endl;
281  for_( entry, updateCollection.begin(), updateCollection.end() )
282  {
283  IdString name ( entry.subFind( sat::SolvAttr::updateCollectionName ).idStr() );
284  Edition edition ( entry.subFind( sat::SolvAttr::updateCollectionEvr ).idStr() );
285  Arch arch ( entry.subFind( sat::SolvAttr::updateCollectionArch ).idStr() );
286  if ( name.empty() )
287  {
288  WAR << "Ignore malformed updateCollection entry: " << name << "-" << edition << "." << arch << endl;
289  continue;
290  }
291 
292  // The entry is relevant if there is an installed
293  // package with the same name and arch.
294  bool relevant = false;
295  sat::WhatProvides providers( (Capability( name.id() )) );
296  for_( it, providers.begin(), providers.end() )
297  {
298  if ( it->isSystem() && it->ident() == name && it->arch() == arch )
299  {
300  relevant = true;
301  break;
302  }
303  }
304  if ( ! relevant )
305  {
306  // DBG << "Not relevant: " << name << "-" << edition << "." << arch << endl;
307  continue;
308  }
309 
310  /* find exact providers first (this matches the _real_ 'collection content' of the patch */
311  providers = sat::WhatProvides( Capability( arch, name.c_str(), Rel::EQ, edition, ResKind::package ) );
312  if ( providers.empty() )
313  {
314  /* no exact providers: find 'best' providers: those with a larger evr */
315  providers = sat::WhatProvides( Capability( arch, name.c_str(), Rel::GT, edition, ResKind::package ) );
316  if ( providers.empty() )
317  {
318  // Hmm, this patch is not installable, no one is providing the package in the collection
319  // FIXME: raise execption ? fake a solvable ?
320  WAR << "Missing provider: " << name << "-" << edition << "." << arch << endl;
321  continue;
322  }
323  }
324 
325  // FIXME ?! loop over providers and try to find installed ones ?
326  // DBG << "Found " << name << "-" << edition << "." << arch << ": " << *(providers.begin()) << endl;
327  result.get().insert( *(providers.begin()) );
328  }
329 
330  return result;
331  }
332 
334  //
335  // CLASS NAME : Patch::ReferenceIterator
336  //
338 
340  { base_reference() = sat::LookupAttr( sat::SolvAttr::updateReference, val_r ).begin(); }
341 
342  std::string Patch::ReferenceIterator::id() const
343  { return base_reference().subFind( sat::SolvAttr::updateReferenceId ).asString(); }
344  std::string Patch::ReferenceIterator::href() const
345  { return base_reference().subFind( sat::SolvAttr::updateReferenceHref ).asString(); }
347  { return base_reference().subFind( sat::SolvAttr::updateReferenceTitle ).asString(); }
348  std::string Patch::ReferenceIterator::type() const
349  { return base_reference().subFind( sat::SolvAttr::updateReferenceType ).asString(); }
350 
352 } // namespace zypp
Architecture.
Definition: Arch.h:37
A sat capability.
Definition: Capability.h:60
Edition represents [epoch:]version[-release]
Definition: Edition.h:61
Access to the sat-pools string space.
Definition: IdString.h:43
'Language[_Country]' codes.
Definition: Locale.h:50
std::string title() const
Title describing the issue.
Definition: Patch.cc:346
std::string id() const
The id of the reference.
Definition: Patch.cc:342
std::string href() const
Url or pointer where to find more information.
Definition: Patch.cc:344
std::string type() const
Type of the reference.
Definition: Patch.cc:348
Class representing a patch.
Definition: Patch.h:38
Category categoryEnum() const
This patch's category as enum of wellknown categories.
Definition: Patch.cc:49
bool isSeverity(const std::string &severity_r) const
Whether this patch's severity matches severity_r.
Definition: Patch.cc:145
bool interactive() const
Is the patch installation interactive? (does it need user input?)
Definition: Patch.cc:259
InteractiveFlag
Flags defining if and why this patch is interactive.
Definition: Patch.h:62
@ License
Definition: Patch.h:66
@ Message
Definition: Patch.h:65
@ Reboot
Definition: Patch.h:64
@ NoFlags
Definition: Patch.h:63
SeverityFlag
Possible severity levels for (security) patches.
Definition: Patch.h:76
@ SEV_CRITICAL
Critical.
Definition: Patch.h:82
@ SEV_LOW
Low.
Definition: Patch.h:79
@ SEV_MODERATE
Moderate.
Definition: Patch.h:80
@ SEV_NONE
no value specified
Definition: Patch.h:78
@ SEV_IMPORTANT
Important.
Definition: Patch.h:81
@ SEV_OTHER
unknown value specified
Definition: Patch.h:77
InteractiveFlags interactiveFlags() const
Get the InteractiveFlags of this Patch.
Definition: Patch.cc:223
std::string severity() const
Severity string as specified in metadata.
Definition: Patch.cc:139
std::string category() const
Patch category (recommended, security,...)
Definition: Patch.cc:46
bool rebootSuggested() const
Does the system need to reboot to finish the update process?
Definition: Patch.cc:214
bool reloginSuggested() const
Does the patch needs the user to relogin to take effect? relogin is suggested then.
Definition: Patch.cc:220
bool isCategory(const std::string &category_r) const
Whether this patch's category matches category_r.
Definition: Patch.cc:52
Contents contents() const
The collection of packages associated with this patch.
Definition: Patch.cc:276
@ CAT_DOCUMENT
Definition: Patch.h:54
@ CAT_YAST
Definition: Patch.h:50
@ CAT_RECOMMENDED
Definition: Patch.h:52
@ CAT_OTHER
unknown value specified
Definition: Patch.h:49
@ CAT_OPTIONAL
Definition: Patch.h:53
@ CAT_SECURITY
Definition: Patch.h:51
virtual ~Patch()
Dtor.
Definition: Patch.cc:41
std::string message(const Locale &lang_r=Locale()) const
Information or warning to be displayed to the user.
Definition: Patch.cc:211
SeverityFlag severityFlag() const
Severity string mapped to an enum.
Definition: Patch.cc:142
bool restartSuggested() const
Does the patch affect the package manager itself? restart is suggested then.
Definition: Patch.cc:217
Patch(const sat::Solvable &solvable_r)
Ctor.
Definition: Patch.cc:32
bool interactiveWhenIgnoring(InteractiveFlags flags_r=NoFlags) const
Is the patch still interactive when ignoring this flags?
Definition: Patch.cc:247
static const ResKind package
Definition: ResKind.h:40
Base for resolvable objects.
Definition: ResObject.h:38
friend ResObject::Ptr makeResObject(const sat::Solvable &solvable_r)
Create ResObject from sat::Solvable.
Definition: ResObject.cc:43
Lightweight attribute value lookup.
Definition: LookupAttr.h:108
iterator end() const
Iterator behind the end of query results.
Definition: LookupAttr.cc:239
iterator begin() const
Iterator to the begin of query results.
Definition: LookupAttr.cc:236
static const SolvAttr updateCollectionArch
Definition: SolvAttr.h:119
static const SolvAttr updateReferenceId
Definition: SolvAttr.h:125
static const SolvAttr updateReferenceType
Definition: SolvAttr.h:123
static const SolvAttr message
Definition: SolvAttr.h:113
static const SolvAttr updateCollectionEvr
Definition: SolvAttr.h:118
static const SolvAttr updateReferenceHref
Definition: SolvAttr.h:124
static const SolvAttr restartSuggested
Definition: SolvAttr.h:111
static const SolvAttr updateCollectionName
Definition: SolvAttr.h:117
static const SolvAttr updateCollection
Definition: SolvAttr.h:116
static const SolvAttr rebootSuggested
Definition: SolvAttr.h:110
static const SolvAttr updateReferenceTitle
Definition: SolvAttr.h:126
static const SolvAttr patchcategory
Definition: SolvAttr.h:109
static const SolvAttr updateReference
Definition: SolvAttr.h:122
static const SolvAttr severity
Definition: SolvAttr.h:114
static const SolvAttr reloginSuggested
Definition: SolvAttr.h:112
Solvable set wrapper to allow adding additional convenience iterators.
Definition: SolvableSet.h:36
Container & get()
The set.
Definition: SolvableSet.h:98
const_iterator end() const
Iterator pointing behind the last Solvable.
Definition: SolvableSet.h:76
const_iterator begin() const
Iterator pointing to the first Solvable.
Definition: SolvableSet.h:72
A Solvable object within the sat Pool.
Definition: Solvable.h:54
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
bool empty() const
Whether the container is empty.
const_iterator begin() const
Iterator pointing to the first Solvable.
std::string hexstring(char n, int w=4)
Definition: String.h:324
std::string toLower(const std::string &s)
Return lowercase version of s.
Definition: String.cc:177
int compareCI(const C_Str &lhs, const C_Str &rhs)
Definition: String.h:984
Easy-to use interface to the ZYPP dependency resolver.
Definition: CodePitfalls.doc:2
std::string asString(const Patch::Category &obj)
Definition: Patch.cc:122
IMPL_PTR_TYPE(Application)
static const Rel GT
Definition: Rel.h:54
static const Rel EQ
Definition: Rel.h:50
bool lookupBoolAttribute(const SolvAttr &attr) const
Definition: SolvableType.h:142
std::string lookupStrAttribute(const SolvAttr &attr) const
Definition: SolvableType.h:140
Solvable satSolvable() const
Return the corresponding sat::Solvable.
Definition: SolvableType.h:57
std::string licenseToConfirm(const Locale &lang_r=Locale()) const
Definition: SolvableType.h:136
#define for_(IT, BEG, END)
Convenient for-loops using iterator.
Definition: Easy.h:28
#define WAR
Definition: Logger.h:97
#define INT
Definition: Logger.h:100