zypp/Product.cc

   1 /*---------------------------------------------------------------------\
   2 |                          ____ _   __ __ ___                          |
   3 |                         |__  / \ / / . \ . \                         |
   4 |                           / / \ V /|  _/  _/                         |
   5 |                          / /__ | | | | | |                           |
   6 |                         /_____||_| |_| |_|                           |
   7 |                                                                      |
   8 \---------------------------------------------------------------------*/
   9 /** \file zypp/Product.cc
  10  *
  11 */
  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
  26 ///////////////////////////////////////////////////////////////////
  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
  58   ///////////////////////////////////////////////////////////////////
  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
  67   ///////////////////////////////////////////////////////////////////
  68   //
  69   //    METHOD NAME : Product::~Product
  70   //    METHOD TYPE : Dtor
  71   //
  72   Product::~Product()
  73   {}
  74
  75   ///////////////////////////////////////////////////////////////////
  76
  77   sat::Solvable Product::referencePackage() const
  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.
 103       sat::LookupAttr q( sat::SolvAttr::filelist, repository() );
 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
 122   { return lookupStrAttribute( sat::SolvAttr::productReferenceFile ); }
 123
 124   Product::ReplacedProducts Product::replacedProducts() const
 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
 150   CapabilitySet Product::droplist() const
 151   { return poolItem().buddy().valuesOfNamespace( "weakremover" ); }
 152
 153   std::string Product::productLine() const
 154   { return lookupStrAttribute( sat::SolvAttr::productProductLine ); }
 155
 156   ///////////////////////////////////////////////////////////////////
 157
 158   std::string Product::shortName() const
 159   { return lookupStrAttribute( sat::SolvAttr::productShortlabel ); }
 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
 191   { return lookupStrAttribute( sat::SolvAttr::productType ); }
 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
 200   bool Product::isTargetDistribution() const
 201   { return isSystem() && lookupStrAttribute( sat::SolvAttr::productType ) == "base"; }
 202
 203   std::string Product::registerTarget() const
 204   { return lookupStrAttribute( sat::SolvAttr::productRegisterTarget ); }
 205
 206   std::string Product::registerRelease() const
 207   { return lookupStrAttribute( sat::SolvAttr::productRegisterRelease ); }
 208
 209   /////////////////////////////////////////////////////////////////
 210
 211   Product::UrlList Product::urls( const std::string & key_r ) const
 212   {
 213     UrlList ret;
 214
 215     sat::LookupAttr url( sat::SolvAttr::productUrl, *this );
 216     sat::LookupAttr url_type( sat::SolvAttr::productUrlType, *this );
 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
 249   /////////////////////////////////////////////////////////////////
 250 } // namespace zypp
 251 ///////////////////////////////////////////////////////////////////