zypp/RepoInfo.cc

   1 /*---------------------------------------------------------------------\
   2 |                          ____ _   __ __ ___                          |
   3 |                         |__  / \ / / . \ . \                         |
   4 |                           / / \ V /|  _/  _/                         |
   5 |                          / /__ | | | | | |                           |
   6 |                         /_____||_| |_| |_|                           |
   7 |                                                                      |
   8 \---------------------------------------------------------------------*/
   9 /** \file       zypp/RepoInfo.cc
  10  *
  11 */
  12 #include <iostream>
  13
  14 #include "zypp/base/Logger.h"
  15 #include "zypp/base/DefaultIntegral.h"
  16 #include "zypp/parser/xml/XmlEscape.h"
  17
  18 #include "zypp/RepoInfo.h"
  19 #include "zypp/repo/RepoInfoBaseImpl.h"
  20 #include "zypp/ExternalProgram.h"
  21 #include "zypp/media/MediaAccess.h"
  22
  23 using namespace std;
  24 using zypp::xml::escape;
  25
  26 ///////////////////////////////////////////////////////////////////
  27 namespace zypp
  28 { /////////////////////////////////////////////////////////////////
  29
  30   ///////////////////////////////////////////////////////////////////
  31   //
  32   //    CLASS NAME : RepoInfo::Impl
  33   //
  34   /** RepoInfo implementation. */
  35   struct RepoInfo::Impl : public repo::RepoInfoBase::Impl
  36   {
  37     Impl()
  38       : repo::RepoInfoBase::Impl()
  39       , gpgcheck(indeterminate)
  40       , keeppackages(indeterminate)
  41       , type(repo::RepoType::NONE_e)
  42     {}
  43
  44     ~Impl()
  45     {}
  46
  47   public:
  48     static const unsigned defaultPriority = 99;
  49
  50     void setProbedType( const repo::RepoType & t ) const
  51     {
  52       if ( type == repo::RepoType::NONE
  53            && t != repo::RepoType::NONE )
  54       {
  55         // lazy init!
  56         const_cast<Impl*>(this)->type = t;
  57       }
  58     }
  59
  60   public:
  61     Pathname licenseTgz() const
  62     { return metadatapath.empty() ? Pathname() : metadatapath / path / "license.tar.gz"; }
  63
  64
  65   public:
  66     TriBool gpgcheck;
  67     TriBool keeppackages;
  68     Url gpgkey_url;
  69     repo::RepoType type;
  70     Url mirrorlist_url;
  71     std::set<Url> baseUrls;
  72     Pathname path;
  73     std::string service;
  74     std::string targetDistro;
  75     Pathname metadatapath;
  76     Pathname packagespath;
  77     DefaultIntegral<unsigned,defaultPriority> priority;
  78   public:
  79
  80   private:
  81     friend Impl * rwcowClone<Impl>( const Impl * rhs );
  82     /** clone for RWCOW_pointer */
  83     Impl * clone() const
  84     { return new Impl( *this ); }
  85   };
  86   ///////////////////////////////////////////////////////////////////
  87
  88   /** \relates RepoInfo::Impl Stream output */
  89   inline std::ostream & operator<<( std::ostream & str, const RepoInfo::Impl & obj )
  90   {
  91     return str << "RepoInfo::Impl";
  92   }
  93
  94   ///////////////////////////////////////////////////////////////////
  95   //
  96   //    CLASS NAME : RepoInfo
  97   //
  98   ///////////////////////////////////////////////////////////////////
  99
 100   const RepoInfo RepoInfo::noRepo;
 101
 102   ///////////////////////////////////////////////////////////////////
 103   //
 104   //    METHOD NAME : RepoInfo::RepoInfo
 105   //    METHOD TYPE : Ctor
 106   //
 107   RepoInfo::RepoInfo()
 108   : _pimpl( new Impl() )
 109   {}
 110
 111   ///////////////////////////////////////////////////////////////////
 112   //
 113   //    METHOD NAME : RepoInfo::~RepoInfo
 114   //    METHOD TYPE : Dtor
 115   //
 116   RepoInfo::~RepoInfo()
 117   {
 118     //MIL << std::endl;
 119   }
 120
 121   unsigned RepoInfo::priority() const
 122   { return _pimpl->priority; }
 123   unsigned RepoInfo::defaultPriority()
 124   { return Impl::defaultPriority; }
 125   void RepoInfo::setPriority( unsigned newval_r )
 126   {
 127     _pimpl->priority = newval_r ? newval_r : Impl::defaultPriority;
 128   }
 129
 130   void RepoInfo::setGpgCheck( bool check )
 131   {
 132     _pimpl->gpgcheck = check;
 133   }
 134
 135   void RepoInfo::setMirrorListUrl( const Url &url )
 136   {
 137     _pimpl->mirrorlist_url = url;
 138   }
 139
 140   void RepoInfo::setGpgKeyUrl( const Url &url )
 141   {
 142     _pimpl->gpgkey_url = url;
 143   }
 144
 145   void RepoInfo::addBaseUrl( const Url &url )
 146   {
 147     _pimpl->baseUrls.insert(url);
 148   }
 149
 150   void RepoInfo::setBaseUrl( const Url &url )
 151   {
 152     _pimpl->baseUrls.clear();
 153     addBaseUrl(url);
 154   }
 155
 156   void RepoInfo::setPath( const Pathname &path )
 157   {
 158     _pimpl->path = path;
 159   }
 160
 161   void RepoInfo::setType( const repo::RepoType &t )
 162   {
 163     _pimpl->type = t;
 164   }
 165
 166   void RepoInfo::setProbedType( const repo::RepoType &t ) const
 167   { _pimpl->setProbedType( t ); }
 168
 169
 170   void RepoInfo::setMetadataPath( const Pathname &path )
 171   {
 172     _pimpl->metadatapath = path;
 173   }
 174
 175   void RepoInfo::setPackagesPath( const Pathname &path )
 176   {
 177     _pimpl->packagespath = path;
 178   }
 179
 180   void RepoInfo::setKeepPackages( bool keep )
 181   {
 182     _pimpl->keeppackages = keep;
 183   }
 184
 185   void RepoInfo::setService( const std::string& name )
 186   {
 187     _pimpl->service = name;
 188   }
 189
 190   void RepoInfo::setTargetDistribution(
 191       const std::string & targetDistribution)
 192   {
 193     _pimpl->targetDistro = targetDistribution;
 194   }
 195
 196   bool RepoInfo::gpgCheck() const
 197   { return indeterminate(_pimpl->gpgcheck) ? true : (bool) _pimpl->gpgcheck; }
 198
 199   Pathname RepoInfo::metadataPath() const
 200   { return _pimpl->metadatapath; }
 201
 202   Pathname RepoInfo::packagesPath() const
 203   { return _pimpl->packagespath; }
 204
 205   repo::RepoType RepoInfo::type() const
 206   { return _pimpl->type; }
 207
 208   Url RepoInfo::mirrorListUrl() const
 209   { return _pimpl->mirrorlist_url; }
 210
 211   Url RepoInfo::gpgKeyUrl() const
 212   { return _pimpl->gpgkey_url; }
 213
 214   std::set<Url> RepoInfo::baseUrls() const
 215   {
 216     RepoInfo::url_set replaced_urls;
 217     repo::RepoVariablesUrlReplacer replacer;
 218     for ( url_set::const_iterator it = _pimpl->baseUrls.begin();
 219           it != _pimpl->baseUrls.end();
 220           ++it )
 221     {
 222       replaced_urls.insert(replacer(*it));
 223     }
 224     return replaced_urls;
 225
 226     return _pimpl->baseUrls;
 227   }
 228
 229   Pathname RepoInfo::path() const
 230   { return _pimpl->path; }
 231
 232   std::string RepoInfo::service() const
 233   { return _pimpl->service; }
 234
 235   std::string RepoInfo::targetDistribution() const
 236   { return _pimpl->targetDistro; }
 237
 238   RepoInfo::urls_const_iterator RepoInfo::baseUrlsBegin() const
 239   {
 240     return make_transform_iterator( _pimpl->baseUrls.begin(),
 241                                     repo::RepoVariablesUrlReplacer() );
 242     //return _pimpl->baseUrls.begin();
 243   }
 244
 245   RepoInfo::urls_const_iterator RepoInfo::baseUrlsEnd() const
 246   {
 247     //return _pimpl->baseUrls.end();
 248     return make_transform_iterator( _pimpl->baseUrls.end(),
 249                                     repo::RepoVariablesUrlReplacer() );
 250   }
 251
 252   RepoInfo::urls_size_type RepoInfo::baseUrlsSize() const
 253   { return _pimpl->baseUrls.size(); }
 254
 255   bool RepoInfo::baseUrlsEmpty() const
 256   { return _pimpl->baseUrls.empty(); }
 257
 258   // false by default (if not set by setKeepPackages)
 259   bool RepoInfo::keepPackages() const
 260   {
 261     if (indeterminate(_pimpl->keeppackages))
 262     {
 263       if (_pimpl->baseUrls.empty())
 264         return false;
 265       else if ( baseUrlsBegin()->schemeIsDownloading() )
 266         return true;
 267       else
 268         return false;
 269     }
 270
 271     return (bool) _pimpl->keeppackages;
 272   }
 273
 274   ///////////////////////////////////////////////////////////////////
 275
 276   bool RepoInfo::hasLicense() const
 277   {
 278     Pathname licenseTgz( _pimpl->licenseTgz() );
 279     SEC << licenseTgz << endl;
 280     SEC << PathInfo(licenseTgz) << endl;
 281
 282     return ! licenseTgz.empty() &&  PathInfo(licenseTgz).isFile();
 283   }
 284
 285   std::string RepoInfo::getLicense( const Locale & lang_r )
 286   {
 287     LocaleSet avlocales( getLicenseLocales() );
 288     if ( avlocales.empty() )
 289       return std::string();
 290
 291     Locale getLang( Locale::bestMatch( avlocales, lang_r ) );
 292     if ( getLang == Locale::noCode
 293          && avlocales.find( Locale::noCode ) == avlocales.end() )
 294     {
 295       WAR << "License.tar.gz contains no fallback text! " << *this << endl;
 296       // Using the fist locale instead of returning no text at all.
 297       // So the user might recognize that there is a license, even if he
 298       // can't read it.
 299       getLang = *avlocales.begin();
 300     }
 301
 302     // now extract the license file.
 303     static const std::string licenseFileFallback( "license.txt" );
 304     std::string licenseFile( getLang == Locale::noCode
 305                              ? licenseFileFallback
 306                              : str::form( "license.%s.txt", getLang.code().c_str() ) );
 307
 308     ExternalProgram::Arguments cmd;
 309     cmd.push_back( "tar" );
 310     cmd.push_back( "-x" );
 311     cmd.push_back( "-z" );
 312     cmd.push_back( "-O" );
 313     cmd.push_back( "-f" );
 314     cmd.push_back( _pimpl->licenseTgz().asString() ); // if it not exists, avlocales was empty.
 315     cmd.push_back( licenseFile );
 316
 317     std::string ret;
 318     ExternalProgram prog( cmd, ExternalProgram::Discard_Stderr );
 319     for ( std::string output( prog.receiveLine() ); output.length(); output = prog.receiveLine() )
 320     {
 321       ret += output;
 322     }
 323     prog.close();
 324     return ret;
 325   }
 326
 327   LocaleSet RepoInfo::getLicenseLocales() const
 328   {
 329     Pathname licenseTgz( _pimpl->licenseTgz() );
 330     if ( licenseTgz.empty() || ! PathInfo( licenseTgz ).isFile() )
 331       return LocaleSet();
 332
 333     ExternalProgram::Arguments cmd;
 334     cmd.push_back( "tar" );
 335     cmd.push_back( "-t" );
 336     cmd.push_back( "-z" );
 337     cmd.push_back( "-f" );
 338     cmd.push_back( licenseTgz.asString() );
 339
 340     LocaleSet ret;
 341     ExternalProgram prog( cmd, ExternalProgram::Stderr_To_Stdout );
 342     for ( std::string output( prog.receiveLine() ); output.length(); output = prog.receiveLine() )
 343     {
 344       static const C_Str license( "license." );
 345       static const C_Str dotTxt( ".txt\n" );
 346       if ( str::hasPrefix( output, license ) && str::hasSuffix( output, dotTxt ) )
 347       {
 348         if ( output.size() <= license.size() +  dotTxt.size() ) // license.txt
 349           ret.insert( Locale() );
 350         else
 351           ret.insert( Locale( std::string( output.c_str()+license.size(), output.size()- license.size() - dotTxt.size() ) ) );
 352       }
 353       else
 354       {
 355         WAR << "  " << output;
 356       }
 357     }
 358     prog.close();
 359     return ret;
 360   }
 361
 362   ///////////////////////////////////////////////////////////////////
 363
 364   std::ostream & RepoInfo::dumpOn( std::ostream & str ) const
 365   {
 366     RepoInfoBase::dumpOn(str);
 367     for ( urls_const_iterator it = baseUrlsBegin();
 368           it != baseUrlsEnd();
 369           ++it )
 370     {
 371       str << "- url         : " << *it << std::endl;
 372     }
 373     str << "- path        : " << path() << std::endl;
 374     str << "- type        : " << type() << std::endl;
 375     str << "- priority    : " << priority() << std::endl;
 376
 377     str << "- gpgcheck    : " << gpgCheck() << std::endl;
 378     str << "- gpgkey      : " << gpgKeyUrl() << std::endl;
 379     str << "- keeppackages: " << keepPackages() << std::endl;
 380     str << "- service     : " << service() << std::endl;
 381
 382     if (!targetDistribution().empty())
 383       str << "- targetdistro: " << targetDistribution() << std::endl;
 384
 385     if (!metadataPath().empty())
 386       str << "- metadataPath: " << metadataPath() << std::endl;
 387
 388     if (!packagesPath().empty())
 389       str << "- packagesPath: " << packagesPath() << std::endl;
 390
 391     return str;
 392   }
 393
 394   std::ostream & RepoInfo::dumpAsIniOn( std::ostream & str ) const
 395   {
 396     RepoInfoBase::dumpAsIniOn(str);
 397
 398     if ( ! _pimpl->baseUrls.empty() )
 399       str << "baseurl=";
 400     for ( url_set::const_iterator it = _pimpl->baseUrls.begin();
 401           it != _pimpl->baseUrls.end();
 402           ++it )
 403     {
 404       str << *it << endl;
 405     }
 406
 407     if ( ! _pimpl->path.empty() )
 408       str << "path="<< path() << endl;
 409
 410     if ( ! (_pimpl->mirrorlist_url.asString().empty()) )
 411       str << "mirrorlist=" << _pimpl->mirrorlist_url << endl;
 412
 413     str << "type=" << type().asString() << endl;
 414
 415     if ( priority() != defaultPriority() )
 416       str << "priority=" << priority() << endl;
 417
 418     if (!indeterminate(_pimpl->gpgcheck))
 419       str << "gpgcheck=" << (gpgCheck() ? "1" : "0") << endl;
 420     if ( ! (gpgKeyUrl().asString().empty()) )
 421       str << "gpgkey=" <<gpgKeyUrl() << endl;
 422
 423     if (!indeterminate(_pimpl->keeppackages))
 424       str << "keeppackages=" << keepPackages() << endl;
 425
 426     if( ! service().empty() )
 427       str << "service=" << service() << endl;
 428
 429     return str;
 430   }
 431
 432   std::ostream & RepoInfo::dumpAsXMLOn( std::ostream & str) const
 433   { return dumpAsXMLOn(str, ""); }
 434
 435   std::ostream & RepoInfo::dumpAsXMLOn( std::ostream & str, const std::string & content) const
 436   {
 437     string tmpstr;
 438     str
 439       << "<repo"
 440       << " alias=\"" << escape(alias()) << "\""
 441       << " name=\"" << escape(name()) << "\"";
 442     if (type() != repo::RepoType::NONE)
 443       str << " type=\"" << type().asString() << "\"";
 444     str
 445       << " enabled=\"" << enabled() << "\""
 446       << " autorefresh=\"" << autorefresh() << "\""
 447       << " gpgcheck=\"" << gpgCheck() << "\"";
 448     if (!(tmpstr = gpgKeyUrl().asString()).empty())
 449       str << " gpgkey=\"" << escape(tmpstr) << "\"";
 450     if (!(tmpstr = mirrorListUrl().asString()).empty())
 451       str << " mirrorlist=\"" << escape(tmpstr) << "\"";
 452     str << ">" << endl;
 453
 454     for (RepoInfo::urls_const_iterator urlit = baseUrlsBegin();
 455          urlit != baseUrlsEnd(); ++urlit)
 456       str << "<url>" << escape(urlit->asString()) << "</url>" << endl;
 457
 458     str << "</repo>" << endl;
 459     return str;
 460   }
 461
 462
 463   std::ostream & operator<<( std::ostream & str, const RepoInfo & obj )
 464   {
 465     return obj.dumpOn(str);
 466   }
 467
 468
 469   /////////////////////////////////////////////////////////////////
 470 } // namespace zypp
 471 ///////////////////////////////////////////////////////////////////