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 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 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 Patch::Contents Patch::contents() const
262 // DBG << *this << endl;
263 sat::LookupAttr updateCollection( sat::SolvAttr::updateCollection, satSolvable() );
264 for_( entry, updateCollection.begin(), updateCollection.end() )
266 IdString name ( entry.subFind( sat::SolvAttr::updateCollectionName ).idStr() );
267 Edition edition ( entry.subFind( sat::SolvAttr::updateCollectionEvr ).idStr() );
268 Arch arch ( entry.subFind( sat::SolvAttr::updateCollectionArch ).idStr() );
271 WAR << "Ignore malformed updateCollection entry: " << name << "-" << edition << "." << arch << endl;
275 // The entry is relevant if there is an installed
276 // package with the same name and arch.
277 bool relevant = false;
278 sat::WhatProvides providers( (Capability( name.id() )) );
279 for_( it, providers.begin(), providers.end() )
281 if ( it->isSystem() && it->ident() == name && it->arch() == arch )
289 // DBG << "Not relevant: " << name << "-" << edition << "." << arch << endl;
293 /* find exact providers first (this matches the _real_ 'collection content' of the patch */
294 providers = sat::WhatProvides( Capability( arch, name.c_str(), Rel::EQ, edition, ResKind::package ) );
295 if ( providers.empty() )
297 /* no exact providers: find 'best' providers: those with a larger evr */
298 providers = sat::WhatProvides( Capability( arch, name.c_str(), Rel::GT, edition, ResKind::package ) );
299 if ( providers.empty() )
301 // Hmm, this patch is not installable, no one is providing the package in the collection
302 // FIXME: raise execption ? fake a solvable ?
303 WAR << "Missing provider: " << name << "-" << edition << "." << arch << endl;
308 // FIXME ?! loop over providers and try to find installed ones ?
309 // DBG << "Found " << name << "-" << edition << "." << arch << ": " << *(providers.begin()) << endl;
310 result.get().insert( *(providers.begin()) );
316 ///////////////////////////////////////////////////////////////////
318 // CLASS NAME : Patch::ReferenceIterator
320 ///////////////////////////////////////////////////////////////////
322 Patch::ReferenceIterator::ReferenceIterator( const sat::Solvable & val_r )
323 { base_reference() = sat::LookupAttr( sat::SolvAttr::updateReference, val_r ).begin(); }
325 std::string Patch::ReferenceIterator::id() const
326 { return base_reference().subFind( sat::SolvAttr::updateReferenceId ).asString(); }
327 std::string Patch::ReferenceIterator::href() const
328 { return base_reference().subFind( sat::SolvAttr::updateReferenceHref ).asString(); }
329 std::string Patch::ReferenceIterator::title() const
330 { return base_reference().subFind( sat::SolvAttr::updateReferenceTitle ).asString(); }
331 std::string Patch::ReferenceIterator::type() const
332 { return base_reference().subFind( sat::SolvAttr::updateReferenceType ).asString(); }
334 /////////////////////////////////////////////////////////////////
336 ///////////////////////////////////////////////////////////////////