1 /*---------------------------------------------------------------------\
3 | |__ / \ / / . \ . \ |
8 \---------------------------------------------------------------------*/
9 /** \file zypp/Patch.cc
14 #include <zypp/base/LogTools.h>
15 #include <zypp/base/String.h>
16 #include <zypp/Patch.h>
17 #include <zypp/sat/WhatProvides.h>
21 ///////////////////////////////////////////////////////////////////
23 { /////////////////////////////////////////////////////////////////
25 IMPL_PTR_TYPE( Patch );
27 ///////////////////////////////////////////////////////////////////
29 // METHOD NAME : Patch::Patch
32 Patch::Patch( const sat::Solvable & solvable_r )
33 : ResObject( solvable_r )
36 ///////////////////////////////////////////////////////////////////
38 // METHOD NAME : Patch::~Patch
44 ///////////////////////////////////////////////////////////////////
46 std::string Patch::category() const
47 { return str::toLower(lookupStrAttribute( sat::SolvAttr::patchcategory )); }
49 Patch::Category Patch::categoryEnum() const
50 { return categoryEnum( category() ); }
52 bool Patch::isCategory( const std::string & category_r ) const
53 { return( str::compareCI( category_r, category() ) == 0 ); }
55 bool Patch::isCategory( Categories category_r ) const
56 { return category_r.testFlag( categoryEnum() ); }
58 Patch::Category Patch::categoryEnum( const std::string & category_r )
60 switch ( category_r[0] )
65 if ( str::compareCI( category_r, "yast" ) == 0 )
72 if ( str::compareCI( category_r, "security" ) == 0 )
79 if ( str::compareCI( category_r, "recommended" ) == 0 )
80 return CAT_RECOMMENDED;
84 if ( str::compareCI( category_r, "bugfix" ) == 0 ) // rhn
85 return CAT_RECOMMENDED;
91 if ( str::compareCI( category_r, "optional" ) == 0 )
96 if ( str::compareCI( category_r, "feature" ) == 0 )
101 if ( str::compareCI( category_r, "enhancement" ) == 0 ) // rhn
108 if ( str::compareCI( category_r, "document" ) == 0 )
113 INT << "Unrecognized Patch::Category string '" << category_r << "'" << endl;
117 std::string asString( const Patch::Category & obj )
121 case Patch::CAT_OTHER: return std::string( "other" ); break;
122 case Patch::CAT_YAST: return std::string( "yast" ); break;
123 case Patch::CAT_SECURITY: return std::string( "security" ); break;
124 case Patch::CAT_RECOMMENDED: return std::string( "recommended" ); break;
125 case Patch::CAT_OPTIONAL: return std::string( "optional" ); break;
126 case Patch::CAT_DOCUMENT: return std::string( "document" ); break;
129 return std::string( "other" );
132 ///////////////////////////////////////////////////////////////////
134 std::string Patch::severity() const
135 { return str::toLower(lookupStrAttribute( sat::SolvAttr::severity )); }
137 Patch::SeverityFlag Patch::severityFlag() const
138 { return severityFlag( severity() ); }
140 bool Patch::isSeverity( const std::string & severity_r ) const
141 { return( str::compareCI( severity_r, severity() ) == 0 ); }
143 bool Patch::isSeverity( SeverityFlags severity_r ) const
144 { return severity_r.testFlag( severityFlag() ); }
146 Patch::SeverityFlag Patch::severityFlag( const std::string & severity_r )
148 switch ( severity_r[0] )
152 if ( str::compareCI( severity_r, "low" ) == 0 )
158 if ( str::compareCI( severity_r, "moderate" ) == 0 )
164 if ( str::compareCI( severity_r, "important" ) == 0 )
165 return SEV_IMPORTANT;
170 if ( str::compareCI( severity_r, "critical" ) == 0 )
176 if ( str::compareCI( severity_r, "unspecified" ) == 0 )
185 INT << "Unrecognized Patch::Severity string '" << severity_r << "'" << endl;
189 std::string asString( const Patch::SeverityFlag & obj )
193 case Patch::SEV_OTHER: return std::string( "unknown" ); break;
194 case Patch::SEV_NONE: return std::string( "unspecified" ); break;
195 case Patch::SEV_LOW: return std::string( "low" ); break;
196 case Patch::SEV_MODERATE: return std::string( "moderate" ); break;
197 case Patch::SEV_IMPORTANT:return std::string( "important" ); break;
198 case Patch::SEV_CRITICAL: return std::string( "critical" ); break;
201 return std::string( "unknown" );
204 ///////////////////////////////////////////////////////////////////
206 std::string Patch::message( const Locale & lang_r ) const
207 { return lookupStrAttribute( sat::SolvAttr::message, lang_r ); }
209 bool Patch::rebootSuggested() const
210 { return lookupBoolAttribute( sat::SolvAttr::rebootSuggested ); }
212 bool Patch::restartSuggested() const
213 { return lookupBoolAttribute( sat::SolvAttr::restartSuggested ); }
215 bool Patch::reloginSuggested() const
216 { return lookupBoolAttribute( sat::SolvAttr::reloginSuggested ); }
218 Patch::InteractiveFlags Patch::interactiveFlags() const
220 InteractiveFlags patchFlags (NoFlags);
221 if ( rebootSuggested() )
222 patchFlags |= Reboot;
224 if ( ! message().empty() )
225 patchFlags |= Message;
227 if ( ! licenseToConfirm().empty() )
228 patchFlags |= License;
230 Patch::Contents c( contents() );
231 for_( it, c.begin(), c.end() )
233 if ( ! makeResObject(*it)->licenseToConfirm().empty() )
235 patchFlags |= License;
242 bool Patch::interactiveWhenIgnoring( InteractiveFlags flags_r ) const
244 if ( interactiveFlags() & ( ~flags_r ) )
254 bool Patch::interactive() const
256 return interactiveWhenIgnoring();
259 std::string asString( const Patch::InteractiveFlag & obj )
263 case Patch::NoFlags: return ""; break;
264 case Patch::Reboot: return "reboot"; break;
265 case Patch::Message: return "message"; break;
266 case Patch::License: return "license"; break;
268 return str::hexstring(obj);
271 Patch::Contents Patch::contents() const
274 // DBG << *this << endl;
275 sat::LookupAttr updateCollection( sat::SolvAttr::updateCollection, satSolvable() );
276 for_( entry, updateCollection.begin(), updateCollection.end() )
278 IdString name ( entry.subFind( sat::SolvAttr::updateCollectionName ).idStr() );
279 Edition edition ( entry.subFind( sat::SolvAttr::updateCollectionEvr ).idStr() );
280 Arch arch ( entry.subFind( sat::SolvAttr::updateCollectionArch ).idStr() );
283 WAR << "Ignore malformed updateCollection entry: " << name << "-" << edition << "." << arch << endl;
287 // The entry is relevant if there is an installed
288 // package with the same name and arch.
289 bool relevant = false;
290 sat::WhatProvides providers( (Capability( name.id() )) );
291 for_( it, providers.begin(), providers.end() )
293 if ( it->isSystem() && it->ident() == name && it->arch() == arch )
301 // DBG << "Not relevant: " << name << "-" << edition << "." << arch << endl;
305 /* find exact providers first (this matches the _real_ 'collection content' of the patch */
306 providers = sat::WhatProvides( Capability( arch, name.c_str(), Rel::EQ, edition, ResKind::package ) );
307 if ( providers.empty() )
309 /* no exact providers: find 'best' providers: those with a larger evr */
310 providers = sat::WhatProvides( Capability( arch, name.c_str(), Rel::GT, edition, ResKind::package ) );
311 if ( providers.empty() )
313 // Hmm, this patch is not installable, no one is providing the package in the collection
314 // FIXME: raise execption ? fake a solvable ?
315 WAR << "Missing provider: " << name << "-" << edition << "." << arch << endl;
320 // FIXME ?! loop over providers and try to find installed ones ?
321 // DBG << "Found " << name << "-" << edition << "." << arch << ": " << *(providers.begin()) << endl;
322 result.get().insert( *(providers.begin()) );
328 ///////////////////////////////////////////////////////////////////
330 // CLASS NAME : Patch::ReferenceIterator
332 ///////////////////////////////////////////////////////////////////
334 Patch::ReferenceIterator::ReferenceIterator( const sat::Solvable & val_r )
335 { base_reference() = sat::LookupAttr( sat::SolvAttr::updateReference, val_r ).begin(); }
337 std::string Patch::ReferenceIterator::id() const
338 { return base_reference().subFind( sat::SolvAttr::updateReferenceId ).asString(); }
339 std::string Patch::ReferenceIterator::href() const
340 { return base_reference().subFind( sat::SolvAttr::updateReferenceHref ).asString(); }
341 std::string Patch::ReferenceIterator::title() const
342 { return base_reference().subFind( sat::SolvAttr::updateReferenceTitle ).asString(); }
343 std::string Patch::ReferenceIterator::type() const
344 { return base_reference().subFind( sat::SolvAttr::updateReferenceType ).asString(); }
346 /////////////////////////////////////////////////////////////////
348 ///////////////////////////////////////////////////////////////////