libzypp  17.5.0
RepoInfo.cc
Go to the documentation of this file.
1 /*---------------------------------------------------------------------\
2 | ____ _ __ __ ___ |
3 | |__ / \ / / . \ . \ |
4 | / / \ V /| _/ _/ |
5 | / /__ | | | | | | |
6 | /_____||_| |_| |_| |
7 | |
8 \---------------------------------------------------------------------*/
12 #include <iostream>
13 #include <vector>
14 
15 #include "zypp/base/LogTools.h"
18 
19 #include "zypp/RepoInfo.h"
20 #include "zypp/Glob.h"
21 #include "zypp/TriBool.h"
22 #include "zypp/Pathname.h"
23 #include "zypp/ZConfig.h"
25 #include "zypp/ExternalProgram.h"
26 #include "zypp/media/MediaAccess.h"
27 
28 #include "zypp/base/IOStream.h"
29 #include "zypp/base/InputStream.h"
30 #include "zypp/parser/xml/Reader.h"
31 
32 using std::endl;
33 using zypp::xml::escape;
34 
36 namespace zypp
37 {
38 
40  //
41  // CLASS NAME : RepoInfo::Impl
42  //
45  {
46  Impl()
47  : _rawGpgCheck( indeterminate )
48  , _rawRepoGpgCheck( indeterminate )
49  , _rawPkgGpgCheck( indeterminate )
50  , _validRepoSignature( indeterminate )
51  , keeppackages(indeterminate)
53  , type(repo::RepoType::NONE_e)
54  , emptybaseurls(false)
55  {}
56 
58  {}
59 
60  public:
61  static const unsigned defaultPriority = 99;
62  static const unsigned noPriority = unsigned(-1);
63 
64  void setProbedType( const repo::RepoType & t ) const
65  {
67  && t != repo::RepoType::NONE )
68  {
69  // lazy init!
70  const_cast<Impl*>(this)->type = t;
71  }
72  }
73 
74  public:
76  Pathname licenseTgz( const std::string & name_r ) const
77  {
78  Pathname ret;
79  if ( !metadataPath().empty() )
80  {
81  std::string licenseStem( "license" );
82  if ( !name_r.empty() )
83  {
84  licenseStem += "-";
85  licenseStem += name_r;
86  }
87 
89  // TODO: REPOMD: this assumes we know the name of the tarball. In fact
90  // we'd need to get the file from repomd.xml (<data type="license[-name_r]">)
91  g.add( metadataPath() / path / ("repodata/*"+licenseStem+".tar.gz") );
92  if ( g.empty() )
93  g.add( metadataPath() / path / (licenseStem+".tar.gz") );
94 
95  if ( !g.empty() )
96  ret = *g.begin();
97  }
98  return ret;
99  }
100 
102  {
103  const Url & mlurl( _mirrorListUrl.transformed() ); // Variables replaced!
104  if ( _baseUrls.empty() && ! mlurl.asString().empty() )
105  {
106  emptybaseurls = true;
107  DBG << "MetadataPath: " << metadataPath() << endl;
109  _baseUrls.raw().insert( _baseUrls.raw().end(), rmurls.getUrls().begin(), rmurls.getUrls().end() );
110  }
111  return _baseUrls;
112  }
113 
115  { return _baseUrls; }
116 
117  bool baseurl2dump() const
118  { return !emptybaseurls && !_baseUrls.empty(); }
119 
120 
122  { return _gpgKeyUrls; }
123 
125  { return _gpgKeyUrls; }
126 
127 
128  const std::set<std::string> & contentKeywords() const
129  { hasContent()/*init if not yet done*/; return _keywords.second; }
130 
131  void addContent( const std::string & keyword_r )
132  { _keywords.second.insert( keyword_r ); if ( ! hasContent() ) _keywords.first = true; }
133 
134  bool hasContent() const
135  {
136  if ( !_keywords.first && ! metadataPath().empty() )
137  {
138  // HACK directly check master index file until RepoManager offers
139  // some content probing and zypper uses it.
141  MIL << "Empty keywords...." << metadataPath() << endl;
142  Pathname master;
143  if ( PathInfo( (master=metadataPath()/"/repodata/repomd.xml") ).isFile() )
144  {
145  //MIL << "GO repomd.." << endl;
146  xml::Reader reader( master );
147  while ( reader.seekToNode( 2, "content" ) )
148  {
149  _keywords.second.insert( reader.nodeText().asString() );
150  reader.seekToEndNode( 2, "content" );
151  }
152  _keywords.first = true; // valid content in _keywords even if empty
153  }
154  else if ( PathInfo( (master=metadataPath()/"/content") ).isFile() )
155  {
156  //MIL << "GO content.." << endl;
157  iostr::forEachLine( InputStream( master ),
158  [this]( int num_r, std::string line_r )->bool
159  {
160  if ( str::startsWith( line_r, "REPOKEYWORDS" ) )
161  {
162  std::vector<std::string> words;
163  if ( str::split( line_r, std::back_inserter(words) ) > 1
164  && words[0].length() == 12 /*"REPOKEYWORDS"*/ )
165  {
166  this->_keywords.second.insert( ++words.begin(), words.end() );
167  }
168  return true; // mult. occurrances are ok.
169  }
170  return( ! str::startsWith( line_r, "META " ) ); // no need to parse into META section.
171  } );
172  _keywords.first = true; // valid content in _keywords even if empty
173  }
175  }
176  return _keywords.first;
177  }
178 
179  bool hasContent( const std::string & keyword_r ) const
180  { return( hasContent() && _keywords.second.find( keyword_r ) != _keywords.second.end() ); }
181 
187  {
188  if ( ! indeterminate(_validRepoSignature) )
189  return _validRepoSignature;
190  // check metadata:
191  if ( ! metadataPath().empty() )
192  {
193  // A missing ".repo_gpgcheck" might be plaindir(no Downloader) or not yet refreshed signed repo!
194  TriBool linkval = triBoolFromPath( metadataPath() / ".repo_gpgcheck" );
195  return linkval;
196  }
197  return indeterminate;
198  }
199 
201  {
202  if ( PathInfo(metadataPath()).isDir() )
203  {
204  Pathname gpgcheckFile( metadataPath() / ".repo_gpgcheck" );
205  if ( PathInfo(gpgcheckFile).isExist() )
206  {
207  TriBool linkval( indeterminate );
208  if ( triBoolFromPath( gpgcheckFile, linkval ) && linkval == value_r )
209  return; // existing symlink fits value_r
210  else
211  filesystem::unlink( gpgcheckFile ); // will write a new one
212  }
213  filesystem::symlink( asString(value_r), gpgcheckFile );
214  }
215  _validRepoSignature = value_r;
216  }
217 
223  {
224  TriBool linkval( true ); // want to see it being switched to indeterminate
225  return triBoolFromPath( metadataPath() / ".repo_gpgcheck", linkval ) && indeterminate(linkval);
226  }
227 
228  bool triBoolFromPath( const Pathname & path_r, TriBool & ret_r ) const
229  {
230  static const Pathname truePath( "true" );
231  static const Pathname falsePath( "false" );
232  static const Pathname indeterminatePath( "indeterminate" );
233 
234  // Quiet readlink;
235  static const ssize_t bufsiz = 63;
236  static char buf[bufsiz+1];
237  ssize_t ret = ::readlink( path_r.c_str(), buf, bufsiz );
238  buf[ret == -1 ? 0 : ret] = '\0';
239 
240  Pathname linkval( buf );
241 
242  bool known = true;
243  if ( linkval == truePath )
244  ret_r = true;
245  else if ( linkval == falsePath )
246  ret_r = false;
247  else if ( linkval == indeterminatePath )
248  ret_r = indeterminate;
249  else
250  known = false;
251  return known;
252  }
253 
254  TriBool triBoolFromPath( const Pathname & path_r ) const
255  { TriBool ret(indeterminate); triBoolFromPath( path_r, ret ); return ret; }
256 
258 
259  private:
263 
264  public:
265  TriBool rawGpgCheck() const { return _rawGpgCheck; }
268 
269  void rawGpgCheck( TriBool val_r ) { _rawGpgCheck = val_r; }
270  void rawRepoGpgCheck( TriBool val_r ) { _rawRepoGpgCheck = val_r; }
271  void rawPkgGpgCheck( TriBool val_r ) { _rawPkgGpgCheck = val_r; }
272 
273  bool cfgGpgCheck() const
274  { return indeterminate(_rawGpgCheck) ? ZConfig::instance().gpgCheck() : (bool)_rawGpgCheck; }
276  { return indeterminate(_rawGpgCheck) && indeterminate(_rawRepoGpgCheck) ? ZConfig::instance().repoGpgCheck() : _rawRepoGpgCheck; }
278  { return indeterminate(_rawGpgCheck) && indeterminate(_rawPkgGpgCheck) ? ZConfig::instance().pkgGpgCheck() : _rawPkgGpgCheck; }
279 
280  private:
282  public:
288  std::string service;
289  std::string targetDistro;
290 
291  void metadataPath( Pathname new_r )
292  { _metadataPath = std::move( new_r ); }
293 
294  void packagesPath( Pathname new_r )
295  { _packagesPath = std::move( new_r ); }
296 
298  { return str::hasSuffix( _metadataPath.asString(), "/%AUTO%" ); }
299 
301  {
302  if ( usesAutoMethadataPaths() )
303  return _metadataPath.dirname() / "%RAW%";
304  return _metadataPath;
305  }
306 
308  {
310  return _metadataPath.dirname() / "%PKG%";
311  return _packagesPath;
312  }
313 
315  mutable bool emptybaseurls;
316 
317  private:
320 
322  mutable std::pair<FalseBool, std::set<std::string> > _keywords;
323 
325 
326  friend Impl * rwcowClone<Impl>( const Impl * rhs );
328  Impl * clone() const
329  { return new Impl( *this ); }
330  };
332 
334  inline std::ostream & operator<<( std::ostream & str, const RepoInfo::Impl & obj )
335  {
336  return str << "RepoInfo::Impl";
337  }
338 
340  //
341  // CLASS NAME : RepoInfo
342  //
344 
346 
348  : _pimpl( new Impl() )
349  {}
350 
352  {}
353 
354  unsigned RepoInfo::priority() const
355  { return _pimpl->priority; }
356 
358  { return Impl::defaultPriority; }
359 
361  { return Impl::noPriority; }
362 
363  void RepoInfo::setPriority( unsigned newval_r )
364  { _pimpl->priority = newval_r ? newval_r : Impl::defaultPriority; }
365 
366 
367  bool RepoInfo::gpgCheck() const
368  { return _pimpl->cfgGpgCheck(); }
369 
371  { _pimpl->rawGpgCheck( value_r ); }
372 
373  void RepoInfo::setGpgCheck( bool value_r ) // deprecated legacy and for squid
374  { setGpgCheck( TriBool(value_r) ); }
375 
376 
378  { return gpgCheck() || _pimpl->cfgRepoGpgCheck(); }
379 
381  {
382  bool ret = ( gpgCheck() && indeterminate(_pimpl->cfgRepoGpgCheck()) ) || _pimpl->cfgRepoGpgCheck();
383  if ( ret && _pimpl->internalUnsignedConfirmed() ) // relax if unsigned repo was confirmed in the past
384  ret = false;
385  return ret;
386  }
387 
389  { _pimpl->rawRepoGpgCheck( value_r ); }
390 
391 
393  { return _pimpl->cfgPkgGpgCheck() || ( gpgCheck() && !bool(validRepoSignature())/*enforced*/ ) ; }
394 
396  { return _pimpl->cfgPkgGpgCheck() || ( gpgCheck() && indeterminate(_pimpl->cfgPkgGpgCheck()) && !bool(validRepoSignature())/*enforced*/ ); }
397 
399  { _pimpl->rawPkgGpgCheck( value_r ); }
400 
401 
402  void RepoInfo::getRawGpgChecks( TriBool & g_r, TriBool & r_r, TriBool & p_r ) const
403  {
404  g_r = _pimpl->rawGpgCheck();
405  r_r = _pimpl->rawRepoGpgCheck();
406  p_r = _pimpl->rawPkgGpgCheck();
407  }
408 
409 
411  {
413  if ( ret && !repoGpgCheck() ) ret = false; // invalidate any old signature if repoGpgCheck is off
414  return ret;
415  }
416 
418  { _pimpl->internalSetValidRepoSignature( value_r ); }
419 
421  namespace
422  {
423  inline bool changeGpgCheckTo( TriBool & lhs, TriBool rhs )
424  { if ( ! sameTriboolState( lhs, rhs ) ) { lhs = rhs; return true; } return false; }
425 
426  inline bool changeGpgCheckTo( TriBool ogpg[3], TriBool g, TriBool r, TriBool p )
427  {
428  bool changed = false;
429  if ( changeGpgCheckTo( ogpg[0], g ) ) changed = true;
430  if ( changeGpgCheckTo( ogpg[1], r ) ) changed = true;
431  if ( changeGpgCheckTo( ogpg[2], p ) ) changed = true;
432  return changed;
433  }
434  } // namespace
437  {
438  TriBool ogpg[3]; // Gpg RepoGpg PkgGpg
439  getRawGpgChecks( ogpg[0], ogpg[1], ogpg[2] );
440 
441  bool changed = false;
442  switch ( mode_r )
443  {
444  case GpgCheck::On:
445  changed = changeGpgCheckTo( ogpg, true, indeterminate, indeterminate );
446  break;
447  case GpgCheck::Strict:
448  changed = changeGpgCheckTo( ogpg, true, true, true );
449  break;
451  changed = changeGpgCheckTo( ogpg, true, false, false );
452  break;
454  changed = changeGpgCheckTo( ogpg, true, false, indeterminate );
455  break;
457  changed = changeGpgCheckTo( ogpg, true, indeterminate, false );
458  break;
459  case GpgCheck::Default:
460  changed = changeGpgCheckTo( ogpg, indeterminate, indeterminate, indeterminate );
461  break;
462  case GpgCheck::Off:
463  changed = changeGpgCheckTo( ogpg, false, indeterminate, indeterminate );
464  break;
465  case GpgCheck::indeterminate: // no change
466  break;
467  }
468 
469  if ( changed )
470  {
471  setGpgCheck ( ogpg[0] );
472  setRepoGpgCheck( ogpg[1] );
473  setPkgGpgCheck ( ogpg[2] );
474  }
475  return changed;
476  }
477 
478  void RepoInfo::setMirrorListUrl( const Url & url_r ) // Raw
479  { _pimpl->_mirrorListUrl.raw() = url_r; _pimpl->_mirrorListForceMetalink = false; }
480 
481  void RepoInfo::setMetalinkUrl( const Url & url_r ) // Raw
482  { _pimpl->_mirrorListUrl.raw() = url_r; _pimpl->_mirrorListForceMetalink = true; }
483 
485  { _pimpl->gpgKeyUrls().raw().swap( urls ); }
486 
487  void RepoInfo::setGpgKeyUrl( const Url & url_r )
488  {
489  _pimpl->gpgKeyUrls().raw().clear();
490  _pimpl->gpgKeyUrls().raw().push_back( url_r );
491  }
492 
493  void RepoInfo::addBaseUrl( const Url & url_r )
494  {
495  for ( const auto & url : _pimpl->baseUrls().raw() ) // Raw unique!
496  if ( url == url_r )
497  return;
498  _pimpl->baseUrls().raw().push_back( url_r );
499  }
500 
501  void RepoInfo::setBaseUrl( const Url & url_r )
502  {
503  _pimpl->baseUrls().raw().clear();
504  _pimpl->baseUrls().raw().push_back( url_r );
505  }
506 
508  { _pimpl->baseUrls().raw().swap( urls ); }
509 
510  void RepoInfo::setPath( const Pathname &path )
511  { _pimpl->path = path; }
512 
514  { _pimpl->type = t; }
515 
517  { _pimpl->setProbedType( t ); }
518 
519 
521  { _pimpl->metadataPath( path ); }
522 
524  { _pimpl->packagesPath( path ); }
525 
526  void RepoInfo::setKeepPackages( bool keep )
527  { _pimpl->keeppackages = keep; }
528 
529  void RepoInfo::setService( const std::string& name )
530  { _pimpl->service = name; }
531 
532  void RepoInfo::setTargetDistribution( const std::string & targetDistribution )
534 
536  { return indeterminate(_pimpl->keeppackages) ? false : (bool)_pimpl->keeppackages; }
537 
539  { return _pimpl->metadataPath(); }
540 
542  { return _pimpl->packagesPath(); }
543 
545  { return _pimpl->usesAutoMethadataPaths(); }
546 
548  { return _pimpl->type; }
549 
550  Url RepoInfo::mirrorListUrl() const // Variables replaced!
551  { return _pimpl->_mirrorListUrl.transformed(); }
552 
554  { return _pimpl->_mirrorListUrl.raw(); }
555 
557  { return _pimpl->gpgKeyUrls().empty(); }
558 
560  { return _pimpl->gpgKeyUrls().size(); }
561 
562  RepoInfo::url_set RepoInfo::gpgKeyUrls() const // Variables replaced!
563  { return _pimpl->gpgKeyUrls().transformed(); }
564 
566  { return _pimpl->gpgKeyUrls().raw(); }
567 
568  Url RepoInfo::gpgKeyUrl() const // Variables replaced!
569  { return( _pimpl->gpgKeyUrls().empty() ? Url() : *_pimpl->gpgKeyUrls().transformedBegin() ); }
570 
572  { return( _pimpl->gpgKeyUrls().empty() ? Url() : *_pimpl->gpgKeyUrls().rawBegin() ) ; }
573 
574  RepoInfo::url_set RepoInfo::baseUrls() const // Variables replaced!
575  { return _pimpl->baseUrls().transformed(); }
576 
578  { return _pimpl->baseUrls().raw(); }
579 
581  { return _pimpl->path; }
582 
583  std::string RepoInfo::service() const
584  { return _pimpl->service; }
585 
586  std::string RepoInfo::targetDistribution() const
587  { return _pimpl->targetDistro; }
588 
590  { return( _pimpl->baseUrls().empty() ? Url() : *_pimpl->baseUrls().rawBegin() ); }
591 
593  { return _pimpl->baseUrls().transformedBegin(); }
594 
596  { return _pimpl->baseUrls().transformedEnd(); }
597 
599  { return _pimpl->baseUrls().size(); }
600 
602  { return _pimpl->baseUrls().empty(); }
603 
604  bool RepoInfo::baseUrlSet() const
605  { return _pimpl->baseurl2dump(); }
606 
607  const std::set<std::string> & RepoInfo::contentKeywords() const
608  { return _pimpl->contentKeywords(); }
609 
610  void RepoInfo::addContent( const std::string & keyword_r )
611  { _pimpl->addContent( keyword_r ); }
612 
613  bool RepoInfo::hasContent() const
614  { return _pimpl->hasContent(); }
615 
616  bool RepoInfo::hasContent( const std::string & keyword_r ) const
617  { return _pimpl->hasContent( keyword_r ); }
618 
620 
621  bool RepoInfo::hasLicense() const
622  { return hasLicense( std::string() ); }
623 
624  bool RepoInfo::hasLicense( const std::string & name_r ) const
625  { return !_pimpl->licenseTgz( name_r ).empty(); }
626 
627 
629  { return needToAcceptLicense( std::string() ); }
630 
631  bool RepoInfo::needToAcceptLicense( const std::string & name_r ) const
632  {
633  const Pathname & licenseTgz( _pimpl->licenseTgz( name_r ) );
634  if ( licenseTgz.empty() )
635  return false; // no licenses at all
636 
638  cmd.push_back( "tar" );
639  cmd.push_back( "-t" );
640  cmd.push_back( "-z" );
641  cmd.push_back( "-f" );
642  cmd.push_back( licenseTgz.asString() );
644 
645  bool accept = true;
646  static const std::string noAcceptanceFile = "no-acceptance-needed\n";
647  for ( std::string output( prog.receiveLine() ); output.length(); output = prog.receiveLine() )
648  {
649  if ( output == noAcceptanceFile )
650  {
651  accept = false;
652  }
653  }
654  prog.close();
655  MIL << "License(" << name_r << ") in " << name() << " has to be accepted: " << (accept?"true":"false" ) << endl;
656  return accept;
657  }
658 
659 
660  std::string RepoInfo::getLicense( const Locale & lang_r )
661  { return const_cast<const RepoInfo *>(this)->getLicense( std::string(), lang_r ); }
662 
663  std::string RepoInfo::getLicense( const Locale & lang_r ) const
664  { return getLicense( std::string(), lang_r ); }
665 
666  std::string RepoInfo::getLicense( const std::string & name_r, const Locale & lang_r ) const
667  {
668  LocaleSet avlocales( getLicenseLocales( name_r ) );
669  if ( avlocales.empty() )
670  return std::string();
671 
672  Locale getLang( Locale::bestMatch( avlocales, lang_r ) );
673  if ( !getLang && avlocales.find( Locale::noCode ) == avlocales.end() )
674  {
675  WAR << "License(" << name_r << ") in " << name() << " contains no fallback text!" << endl;
676  // Using the fist locale instead of returning no text at all.
677  // So the user might recognize that there is a license, even if he
678  // can't read it.
679  getLang = *avlocales.begin();
680  }
681 
682  // now extract the license file.
683  static const std::string licenseFileFallback( "license.txt" );
684  std::string licenseFile( !getLang ? licenseFileFallback
685  : str::form( "license.%s.txt", getLang.c_str() ) );
686 
688  cmd.push_back( "tar" );
689  cmd.push_back( "-x" );
690  cmd.push_back( "-z" );
691  cmd.push_back( "-O" );
692  cmd.push_back( "-f" );
693  cmd.push_back( _pimpl->licenseTgz( name_r ).asString() ); // if it not exists, avlocales was empty.
694  cmd.push_back( licenseFile );
695 
696  std::string ret;
698  for ( std::string output( prog.receiveLine() ); output.length(); output = prog.receiveLine() )
699  {
700  ret += output;
701  }
702  prog.close();
703  return ret;
704  }
705 
706 
708  { return getLicenseLocales( std::string() ); }
709 
710  LocaleSet RepoInfo::getLicenseLocales( const std::string & name_r ) const
711  {
712  const Pathname & licenseTgz( _pimpl->licenseTgz( name_r ) );
713  if ( licenseTgz.empty() )
714  return LocaleSet();
715 
717  cmd.push_back( "tar" );
718  cmd.push_back( "-t" );
719  cmd.push_back( "-z" );
720  cmd.push_back( "-f" );
721  cmd.push_back( licenseTgz.asString() );
722 
723  LocaleSet ret;
725  for ( std::string output( prog.receiveLine() ); output.length(); output = prog.receiveLine() )
726  {
727  static const C_Str license( "license." );
728  static const C_Str dotTxt( ".txt\n" );
729  if ( str::hasPrefix( output, license ) && str::hasSuffix( output, dotTxt ) )
730  {
731  if ( output.size() <= license.size() + dotTxt.size() ) // license.txt
732  ret.insert( Locale() );
733  else
734  ret.insert( Locale( std::string( output.c_str()+license.size(), output.size()- license.size() - dotTxt.size() ) ) );
735  }
736  }
737  prog.close();
738  return ret;
739  }
740 
742 
743  std::ostream & RepoInfo::dumpOn( std::ostream & str ) const
744  {
746  if ( _pimpl->baseurl2dump() )
747  {
748  for ( const auto & url : _pimpl->baseUrls().raw() )
749  {
750  str << "- url : " << url << std::endl;
751  }
752  }
753 
754  // print if non empty value
755  auto strif( [&] ( const std::string & tag_r, const std::string & value_r ) {
756  if ( ! value_r.empty() )
757  str << tag_r << value_r << std::endl;
758  });
759 
760  strif( (_pimpl->_mirrorListForceMetalink ? "- metalink : " : "- mirrorlist : "), rawMirrorListUrl().asString() );
761  strif( "- path : ", path().asString() );
762  str << "- type : " << type() << std::endl;
763  str << "- priority : " << priority() << std::endl;
764 
765  // Yes No Default(Y) Default(N)
766 #define OUTS(T,B) ( indeterminate(T) ? (std::string("D(")+(B?"Y":"N")+")") : ((bool)T?"Y":"N") )
767  str << "- gpgcheck : " << OUTS(_pimpl->rawGpgCheck(),gpgCheck())
768  << " repo" << OUTS(_pimpl->rawRepoGpgCheck(),repoGpgCheck()) << (repoGpgCheckIsMandatory() ? "* ": " " )
769  << "sig" << asString( validRepoSignature(), "?", "Y", "N" )
770  << " pkg" << OUTS(_pimpl->rawPkgGpgCheck(),pkgGpgCheck()) << (pkgGpgCheckIsMandatory() ? "* ": " " )
771  << std::endl;
772 #undef OUTS
773 
774  for ( const auto & url : _pimpl->gpgKeyUrls().raw() )
775  {
776  str << "- gpgkey : " << url << std::endl;
777  }
778 
779  if ( ! indeterminate(_pimpl->keeppackages) )
780  str << "- keeppackages: " << keepPackages() << std::endl;
781 
782  strif( "- service : ", service() );
783  strif( "- targetdistro: ", targetDistribution() );
784  strif( "- filePath: ", filepath().asString() );
785  strif( "- metadataPath: ", metadataPath().asString() );
786  strif( "- packagesPath: ", packagesPath().asString() );
787 
788  return str;
789  }
790 
791  std::ostream & RepoInfo::dumpAsIniOn( std::ostream & str ) const
792  {
793  RepoInfoBase::dumpAsIniOn(str);
794 
795  if ( _pimpl->baseurl2dump() )
796  {
797  str << "baseurl=";
798  std::string indent;
799  for ( const auto & url : _pimpl->baseUrls().raw() )
800  {
801  str << indent << url << endl;
802  if ( indent.empty() ) indent = " "; // "baseurl="
803  }
804  }
805 
806  if ( ! _pimpl->path.empty() )
807  str << "path="<< path() << endl;
808 
809  if ( ! (rawMirrorListUrl().asString().empty()) )
810  str << (_pimpl->_mirrorListForceMetalink ? "metalink=" : "mirrorlist=") << rawMirrorListUrl() << endl;
811 
812  str << "type=" << type().asString() << endl;
813 
814  if ( priority() != defaultPriority() )
815  str << "priority=" << priority() << endl;
816 
817  if ( ! indeterminate(_pimpl->rawGpgCheck()) )
818  str << "gpgcheck=" << (_pimpl->rawGpgCheck() ? "1" : "0") << endl;
819 
820  if ( ! indeterminate(_pimpl->rawRepoGpgCheck()) )
821  str << "repo_gpgcheck=" << (_pimpl->rawRepoGpgCheck() ? "1" : "0") << endl;
822 
823  if ( ! indeterminate(_pimpl->rawPkgGpgCheck()) )
824  str << "pkg_gpgcheck=" << (_pimpl->rawPkgGpgCheck() ? "1" : "0") << endl;
825 
826  {
827  std::string indent( "gpgkey=");
828  for ( const auto & url : _pimpl->gpgKeyUrls().raw() )
829  {
830  str << indent << url << endl;
831  if ( indent[0] != ' ' )
832  indent = " ";
833  }
834  }
835 
836  if (!indeterminate(_pimpl->keeppackages))
837  str << "keeppackages=" << keepPackages() << endl;
838 
839  if( ! service().empty() )
840  str << "service=" << service() << endl;
841 
842  return str;
843  }
844 
845  std::ostream & RepoInfo::dumpAsXmlOn( std::ostream & str, const std::string & content ) const
846  {
847  std::string tmpstr;
848  str
849  << "<repo"
850  << " alias=\"" << escape(alias()) << "\""
851  << " name=\"" << escape(name()) << "\"";
852  if (type() != repo::RepoType::NONE)
853  str << " type=\"" << type().asString() << "\"";
854  str
855  << " priority=\"" << priority() << "\""
856  << " enabled=\"" << enabled() << "\""
857  << " autorefresh=\"" << autorefresh() << "\""
858  << " gpgcheck=\"" << gpgCheck() << "\""
859  << " repo_gpgcheck=\"" << repoGpgCheck() << "\""
860  << " pkg_gpgcheck=\"" << pkgGpgCheck() << "\"";
861  if (!(tmpstr = gpgKeyUrl().asString()).empty())
862  str << " gpgkey=\"" << escape(tmpstr) << "\"";
863  if (!(tmpstr = mirrorListUrl().asString()).empty())
864  str << (_pimpl->_mirrorListForceMetalink ? " metalink=\"" : " mirrorlist=\"") << escape(tmpstr) << "\"";
865  str << ">" << endl;
866 
867  if ( _pimpl->baseurl2dump() )
868  {
869  for_( it, baseUrlsBegin(), baseUrlsEnd() ) // !transform iterator replaces variables
870  str << "<url>" << escape((*it).asString()) << "</url>" << endl;
871  }
872 
873  str << "</repo>" << endl;
874  return str;
875  }
876 
877 
878  std::ostream & operator<<( std::ostream & str, const RepoInfo & obj )
879  {
880  return obj.dumpOn(str);
881  }
882 
883  std::ostream & operator<<( std::ostream & str, const RepoInfo::GpgCheck & obj )
884  {
885  switch ( obj )
886  {
887 #define OUTS( V ) case RepoInfo::V: return str << #V; break
888  OUTS( GpgCheck::On );
889  OUTS( GpgCheck::Strict );
890  OUTS( GpgCheck::AllowUnsigned );
891  OUTS( GpgCheck::AllowUnsignedRepo );
892  OUTS( GpgCheck::AllowUnsignedPackage );
893  OUTS( GpgCheck::Default );
894  OUTS( GpgCheck::Off );
895  OUTS( GpgCheck::indeterminate );
896 #undef OUTS
897  }
898  return str << "GpgCheck::UNKNOWN";
899  }
900 
902 } // namespace zypp
static const Locale noCode
Empty code.
Definition: Locale.h:74
Pathname filepath() const
File where this repo was read from.
Pathname path() const
Repository path.
Definition: RepoInfo.cc:580
unsigned priority() const
Repository priority for solver.
Definition: RepoInfo.cc:354
#define MIL
Definition: Logger.h:64
bool hasLicense() const
Whether there is a license associated with the repo.
Definition: RepoInfo.cc:621
url_set gpgKeyUrls() const
The list of gpgkey URLs defined for this repo.
Definition: RepoInfo.cc:562
void setGpgKeyUrl(const Url &gpgkey)
(leagcy API) Set the gpgkey URL defined for this repo
Definition: RepoInfo.cc:487
static unsigned defaultPriority()
The default priority (99).
Definition: RepoInfo.cc:357
Url rawGpgKeyUrl() const
(leagcy API) The 1st raw gpgkey URL defined for this repo (no variables replaced) ...
Definition: RepoInfo.cc:571
Url rawUrl() const
Pars pro toto: The first repository raw url (no variables replaced)
Definition: RepoInfo.cc:589
TriBool rawPkgGpgCheck() const
Definition: RepoInfo.cc:267
const std::set< std::string > & contentKeywords() const
Content keywords defined.
Definition: RepoInfo.cc:607
void packagesPath(Pathname new_r)
Definition: RepoInfo.cc:294
std::string asString(const DefaultIntegral< Tp, TInitial > &obj)
virtual std::ostream & dumpOn(std::ostream &str) const
Write a human-readable representation of this RepoInfo object into the str stream.
Definition: RepoInfo.cc:743
bool _mirrorListForceMetalink
Definition: RepoInfo.cc:285
static ZConfig & instance()
Singleton ctor.
Definition: Resolver.cc:125
std::string service() const
Gets name of the service to which this repository belongs or empty string if it has been added manual...
Definition: RepoInfo.cc:583
void setProbedType(const repo::RepoType &t) const
This allows to adjust the RepoType lazy, from NONE to some probed value, even for const objects...
Definition: RepoInfo.cc:516
void setPriority(unsigned newval_r)
Set repository priority for solver.
Definition: RepoInfo.cc:363
int readlink(const Pathname &symlink_r, Pathname &target_r)
Like &#39;readlink&#39;.
Definition: PathInfo.cc:877
void rawGpgCheck(TriBool val_r)
Definition: RepoInfo.cc:269
RWCOW_pointer< Impl > _pimpl
Pointer to implementation.
Definition: RepoInfo.h:549
void setMirrorListUrl(const Url &url)
Set mirror list url.
Definition: RepoInfo.cc:478
std::ostream & dumpOn(std::ostream &str, const zypp::shared_ptr< void > &obj)
Definition: PtrTypes.h:151
const char * c_str() const
String representation.
Definition: Pathname.h:109
std::ostream & operator<<(std::ostream &str, const RepoInfo::Impl &obj)
Definition: RepoInfo.cc:334
bool pkgGpgCheckIsMandatory() const
Mandatory check (pkgGpgCheck is not off) must ask to confirm using unsigned packages.
Definition: RepoInfo.cc:395
url_set rawGpgKeyUrls() const
The list of raw gpgkey URLs defined for this repo (no variables replaced)
Definition: RepoInfo.cc:565
String related utilities and Regular expression matching.
std::list< Url > url_set
Definition: RepoInfo.h:103
bool hasContent() const
Definition: RepoInfo.cc:134
What is known about a repository.
Definition: RepoInfo.h:71
void setGpgCheck(TriBool value_r)
Set the value for gpgCheck (or indeterminate to use the default).
Definition: RepoInfo.cc:370
TriBool _rawPkgGpgCheck
need to check pkg sign.: Y/N/(ZConf(Y/N/gpgCheck))
Definition: RepoInfo.cc:262
unsigned split(const C_Str &line_r, TOutputIterator result_r, const C_Str &sepchars_r=" \)
Split line_r into words.
Definition: String.h:502
Helper to create and pass std::istream.
Definition: InputStream.h:56
#define for_(IT, BEG, END)
Convenient for-loops using iterator.
Definition: Easy.h:27
void setBaseUrl(const Url &url)
Clears current base URL list and adds url.
Definition: RepoInfo.cc:501
bool usesAutoMethadataPaths() const
Definition: RepoInfo.cc:297
std::string form(const char *format,...) __attribute__((format(printf
Printf style construction of std::string.
Definition: String.cc:36
bool enabled() const
If enabled is false, then this repository must be ignored as if does not exists, except when checking...
void internalSetValidRepoSignature(TriBool value_r)
Definition: RepoInfo.cc:200
Url gpgKeyUrl() const
(leagcy API) The 1st gpgkey URL defined for this repo
Definition: RepoInfo.cc:568
TriBool internalValidRepoSignature() const
Signature check result needs to be stored/retrieved from _metadataPath.
Definition: RepoInfo.cc:186
base::ValueTransform< Url, repo::RepoVariablesUrlReplacer > RepoVariablesReplacedUrl
#define OUTS(T, B)
bool repoGpgCheck() const
Whether the signature of repo metadata should be checked for this repo.
Definition: RepoInfo.cc:377
bool triBoolFromPath(const Pathname &path_r, TriBool &ret_r) const
Definition: RepoInfo.cc:228
const_iterator begin() const
Iterator pointing to the first result.
Definition: Glob.h:197
bool usesAutoMethadataPaths() const
Whether metadataPath uses AUTO% setup.
Definition: RepoInfo.cc:544
void setValidRepoSignature(TriBool value_r)
Set the value for validRepoSignature (or indeterminate if unsigned).
Definition: RepoInfo.cc:417
std::vector< std::string > Arguments
urls_const_iterator baseUrlsBegin() const
iterator that points at begin of repository urls
Definition: RepoInfo.cc:592
bool seekToNode(int depth_r, const std::string &name_r)
Definition: Reader.cc:212
boost::logic::tribool TriBool
3-state boolean logic (true, false and indeterminate).
Definition: String.h:30
bool baseUrlsEmpty() const
whether repository urls are available
Definition: RepoInfo.cc:601
transform_iterator< repo::RepoVariablesUrlReplacer, url_set::const_iterator > urls_const_iterator
Definition: RepoInfo.h:105
size_type size() const
Definition: String.h:105
Pathname _metadataPath
Definition: RepoInfo.cc:318
const std::string & asString() const
Definition: RepoType.cc:56
RepoVariablesReplacedUrlList _baseUrls
Definition: RepoInfo.cc:321
static Locale bestMatch(const LocaleSet &avLocales_r, Locale requested_r=Locale())
Return the best match for Locale requested_r within the available avLocales_r.
Definition: Locale.cc:213
Url url() const
Pars pro toto: The first repository url.
Definition: RepoInfo.h:131
Url mirrorListUrl() const
Url of a file which contains a list of repository urls.
Definition: RepoInfo.cc:550
RepoInfo implementation.
Definition: RepoInfo.cc:44
bool empty() const
Test for an empty path.
Definition: Pathname.h:113
bool keepPackages() const
Whether packages downloaded from this repository will be kept in local cache.
Definition: RepoInfo.cc:535
bool gpgKeyUrlsEmpty() const
Whether gpgkey URLs are defined.
Definition: RepoInfo.cc:556
std::string escape(const C_Str &str_r, const char sep_r)
Escape desired character c using a backslash.
Definition: String.cc:369
virtual ~RepoInfo()
Definition: RepoInfo.cc:351
GpgCheck
Some predefined settings.
Definition: RepoInfo.h:365
TriBool pkgGpgCheck() const
Check rpm package signatures (indeterminate - according to gpgcheck)
Definition: ZConfig.cc:1048
bool pkgGpgCheck() const
Whether the signature of rpm packages should be checked for this repo.
Definition: RepoInfo.cc:392
std::ostream & operator<<(std::ostream &str, const Exception &obj)
Definition: Exception.cc:147
Pathname packagesPath() const
Definition: RepoInfo.cc:307
Execute a program and give access to its io An object of this class encapsulates the execution of an ...
int unlink(const Pathname &path)
Like &#39;unlink&#39;.
Definition: PathInfo.cc:653
bool repoGpgCheckIsMandatory() const
Mandatory check (repoGpgCheck is on) must ask to confirm using unsigned repos.
Definition: RepoInfo.cc:380
RepoVariablesReplacedUrlList & baseUrls()
Definition: RepoInfo.cc:114
void setRepoGpgCheck(TriBool value_r)
Set the value for repoGpgCheck (or indeterminate to use the default).
Definition: RepoInfo.cc:388
const std::string & asString() const
String representation.
Definition: Pathname.h:90
TriBool triBoolFromPath(const Pathname &path_r) const
Definition: RepoInfo.cc:254
std::string alias() const
unique identifier for this source.
void addContent(const std::string &keyword_r)
Definition: RepoInfo.cc:131
bool gpgCheck() const
Turn signature checking on/off (on)
Definition: ZConfig.cc:1046
Convenience char* constructible from std::string and char*, it maps (char*)0 to an empty string...
Definition: String.h:90
int forEachLine(std::istream &str_r, function< bool(int, std::string)> consume_r)
Simple lineparser: Call functor consume_r for each line.
Definition: IOStream.cc:100
Url rawMirrorListUrl() const
The raw mirrorListUrl (no variables replaced).
Definition: RepoInfo.cc:553
void setPath(const Pathname &path)
set the product path.
Definition: RepoInfo.cc:510
TriBool validRepoSignature() const
Whether the repo metadata are signed and successfully validated or indeterminate if unsigned...
Definition: RepoInfo.cc:410
Pathname dirname() const
Return all but the last component od this path.
Definition: Pathname.h:123
LocaleSet getLicenseLocales() const
Return the locales the license is available for.
Definition: RepoInfo.cc:707
void setService(const std::string &name)
sets service which added this repository
Definition: RepoInfo.cc:529
#define WAR
Definition: Logger.h:65
void setMetadataPath(const Pathname &path)
Set the path where the local metadata is stored.
Definition: RepoInfo.cc:520
bool baseUrlSet() const
Whether there are manualy configured repository urls.
Definition: RepoInfo.cc:604
RepoVariablesReplacedUrlList & gpgKeyUrls()
Definition: RepoInfo.cc:124
bool startsWith(const C_Str &str_r, const C_Str &prefix_r)
alias for hasPrefix
Definition: String.h:1069
void getRawGpgChecks(TriBool &g_r, TriBool &r_r, TriBool &p_r) const
Raw values for RepoManager.
Definition: RepoInfo.cc:402
void setType(const repo::RepoType &t)
set the repository type
Definition: RepoInfo.cc:513
TriBool repoGpgCheck() const
Check repo matadata signatures (indeterminate - according to gpgcheck)
Definition: ZConfig.cc:1047
bool gpgCheck() const
Whether default signature checking should be performed.
Definition: RepoInfo.cc:367
TriBool _rawGpgCheck
default gpgcheck behavior: Y/N/ZConf
Definition: RepoInfo.cc:260
TriBool _validRepoSignature
have signed and valid repo metadata
Definition: RepoInfo.cc:281
bool hasContent() const
Check for content keywords.
Definition: RepoInfo.cc:613
std::pair< FalseBool, std::set< std::string > > _keywords
Definition: RepoInfo.cc:322
void setKeepPackages(bool keep)
Set if packaqes downloaded from this repository will be kept in local cache.
Definition: RepoInfo.cc:526
std::string getLicense(const Locale &lang_r=Locale()) const
Return the best license for the current (or a specified) locale.
Definition: RepoInfo.cc:663
bool baseurl2dump() const
Definition: RepoInfo.cc:117
bool empty() const
Whether matches were found.
Definition: Glob.h:189
bool seekToEndNode(int depth_r, const std::string &name_r)
Definition: Reader.cc:232
const RepoVariablesReplacedUrlList & baseUrls() const
Definition: RepoInfo.cc:101
int symlink(const Pathname &oldpath, const Pathname &newpath)
Like &#39;symlink&#39;.
Definition: PathInfo.cc:808
void addBaseUrl(const Url &url)
Add a base url.
Definition: RepoInfo.cc:493
TriBool cfgPkgGpgCheck() const
Definition: RepoInfo.cc:277
std::string receiveLine()
Read one line from the input stream.
bool cfgGpgCheck() const
Definition: RepoInfo.cc:273
TriBool _rawRepoGpgCheck
need to check repo sign.: Y/N/(ZConf(Y/N/gpgCheck))
Definition: RepoInfo.cc:261
Find pathnames matching a pattern.
Definition: Glob.h:57
Pathname metadataPath() const
Path where this repo metadata was read from.
Definition: RepoInfo.cc:538
static const RepoType NONE
Definition: RepoType.h:32
static const unsigned noPriority
Definition: RepoInfo.cc:62
base::ContainerTransform< std::list< Url >, repo::RepoVariablesUrlReplacer > RepoVariablesReplacedUrlList
int add(const Pathname &pattern_r, Flags flags_r=Flags())
Add pathnames matching pattern_r to the current result.
Definition: Glob.h:155
void setPackagesPath(const Pathname &path)
set the path where the local packages are stored
Definition: RepoInfo.cc:523
virtual std::ostream & dumpAsXmlOn(std::ostream &str, const std::string &content="") const
Write an XML representation of this RepoInfo object.
Definition: RepoInfo.cc:845
&#39;Language[_Country]&#39; codes.
Definition: Locale.h:49
int close()
Wait for the progamm to complete.
void setMetalinkUrl(const Url &url)
Like setMirrorListUrl but expect metalink format.
Definition: RepoInfo.cc:481
void setGpgKeyUrls(url_set urls)
Set a list of gpgkey URLs defined for this repo.
Definition: RepoInfo.cc:484
const std::set< std::string > & contentKeywords() const
Definition: RepoInfo.cc:128
void setProbedType(const repo::RepoType &t) const
Definition: RepoInfo.cc:64
url_set::size_type urls_size_type
Definition: RepoInfo.h:104
bool hasSuffix(const C_Str &str_r, const C_Str &suffix_r)
Return whether str_r has suffix suffix_r.
Definition: String.h:1025
void rawRepoGpgCheck(TriBool val_r)
Definition: RepoInfo.cc:270
url_set rawBaseUrls() const
The complete set of raw repository urls (no variables replaced)
Definition: RepoInfo.cc:577
void setTargetDistribution(const std::string &targetDistribution)
Sets the distribution for which is this repository meant.
Definition: RepoInfo.cc:532
bool needToAcceptLicense() const
Whether the repo license has to be accepted, e.g.
Definition: RepoInfo.cc:628
virtual std::ostream & dumpAsIniOn(std::ostream &str) const
Write this RepoInfo object into str in a .repo file format.
Definition: RepoInfo.cc:791
XmlString nodeText()
If the current node is not empty, advances the reader to the next node, and returns the value...
Definition: Reader.cc:140
const RepoVariablesReplacedUrlList & gpgKeyUrls() const
Definition: RepoInfo.cc:121
std::string name() const
Repository name.
std::string asString() const
Explicit conversion to std::string.
Definition: XmlString.h:77
Pathname licenseTgz(const std::string &name_r) const
Path to a license tarball in case it exists in the repo.
Definition: RepoInfo.cc:76
bool internalUnsignedConfirmed() const
We definitely have a symlink pointing to "indeterminate" (for repoGpgCheckIsMandatory)? I.e.
Definition: RepoInfo.cc:222
RepoVariablesReplacedUrlList _gpgKeyUrls
Definition: RepoInfo.cc:324
TriBool rawRepoGpgCheck() const
Definition: RepoInfo.cc:266
RepoVariablesReplacedUrl _mirrorListUrl
Definition: RepoInfo.cc:284
DefaultIntegral< unsigned, defaultPriority > priority
Definition: RepoInfo.cc:314
std::string targetDistribution() const
Distribution for which is this repository meant.
Definition: RepoInfo.cc:586
Pathname packagesPath() const
Path where this repo packages are cached.
Definition: RepoInfo.cc:541
void setBaseUrls(url_set urls)
Clears current base URL list and adds an url_set.
Definition: RepoInfo.cc:507
std::string targetDistro
Definition: RepoInfo.cc:289
Wrapper class for ::stat/::lstat.
Definition: PathInfo.h:220
static const RepoInfo noRepo
Represents no Repository (one with an empty alias).
Definition: RepoInfo.h:80
urls_const_iterator baseUrlsEnd() const
iterator that points at end of repository urls
Definition: RepoInfo.cc:595
void addContent(const std::string &keyword_r)
Add content keywords.
Definition: RepoInfo.cc:610
void rawPkgGpgCheck(TriBool val_r)
Definition: RepoInfo.cc:271
bool autorefresh() const
If true, the repostory must be refreshed before creating resolvables from it.
urls_size_type baseUrlsSize() const
number of repository urls
Definition: RepoInfo.cc:598
const std::vector< Url > & getUrls() const
repo::RepoType type
Definition: RepoInfo.cc:286
urls_size_type gpgKeyUrlsSize() const
Number of gpgkey URLs defined.
Definition: RepoInfo.cc:559
Pathname metadataPath() const
Definition: RepoInfo.cc:300
TriBool rawGpgCheck() const
Definition: RepoInfo.cc:265
Easy-to use interface to the ZYPP dependency resolver.
Definition: CodePitfalls.doc:1
static const unsigned defaultPriority
Definition: RepoInfo.cc:61
Impl * clone() const
clone for RWCOW_pointer
Definition: RepoInfo.cc:328
static unsigned noPriority()
The least priority (unsigned(-1)).
Definition: RepoInfo.cc:360
bool hasPrefix(const C_Str &str_r, const C_Str &prefix_r)
Return whether str_r has prefix prefix_r.
Definition: String.h:1011
url_set baseUrls() const
The complete set of repository urls.
Definition: RepoInfo.cc:574
void setPkgGpgCheck(TriBool value_r)
Set the value for pkgGpgCheck (or indeterminate to use the default).
Definition: RepoInfo.cc:398
repo::RepoType type() const
Type of repository,.
Definition: RepoInfo.cc:547
std::unordered_set< Locale > LocaleSet
Definition: Locale.h:27
TriBool cfgRepoGpgCheck() const
Definition: RepoInfo.cc:275
const char * c_str() const
Definition: IdStringType.h:105
Pathname _packagesPath
Definition: RepoInfo.cc:319
Url manipulation class.
Definition: Url.h:87
void metadataPath(Pathname new_r)
Definition: RepoInfo.cc:291
#define DBG
Definition: Logger.h:63
std::string service
Definition: RepoInfo.cc:288
detail::EscapedString escape(const std::string &in_r)
Escape xml special charaters (& -> &; from IoBind library).
Definition: XmlEscape.h:51
Repository type enumeration.
Definition: RepoType.h:27
bool hasContent(const std::string &keyword_r) const
Definition: RepoInfo.cc:179