ce7d069bf03d60e4e675b8217a41593d383c1687
[platform/upstream/libzypp.git] / zypp / RepoManager.cc
1 /*---------------------------------------------------------------------\
2 |                          ____ _   __ __ ___                          |
3 |                         |__  / \ / / . \ . \                         |
4 |                           / / \ V /|  _/  _/                         |
5 |                          / /__ | | | | | |                           |
6 |                         /_____||_| |_| |_|                           |
7 |                                                                      |
8 \---------------------------------------------------------------------*/
9 /** \file       zypp/RepoManager.cc
10  *
11 */
12
13 #include <iostream>
14 #include <fstream>
15 #include <list>
16 #include <algorithm>
17 #include "zypp/base/InputStream.h"
18 #include "zypp/base/Logger.h"
19 #include "zypp/base/Gettext.h"
20 #include "zypp/base/Function.h"
21 #include "zypp/PathInfo.h"
22 #include "zypp/TmpPath.h"
23
24 #include "zypp/repo/RepoException.h"
25 #include "zypp/RepoManager.h"
26
27 #include "zypp/cache/CacheStore.h"
28 #include "zypp/repo/cached/RepoImpl.h"
29 #include "zypp/media/MediaManager.h"
30 #include "zypp/MediaSetAccess.h"
31
32 #include "zypp/parser/RepoFileReader.h"
33 #include "zypp/repo/yum/Downloader.h"
34 #include "zypp/parser/yum/RepoParser.h"
35 #include "zypp/parser/plaindir/RepoParser.h"
36 #include "zypp/repo/susetags/Downloader.h"
37 #include "zypp/parser/susetags/RepoParser.h"
38
39 #include "zypp/ZYppCallbacks.h"
40
41 using namespace std;
42 using namespace zypp;
43 using namespace zypp::repo;
44 using namespace zypp::filesystem;
45
46 using namespace zypp::repo;
47
48 ///////////////////////////////////////////////////////////////////
49 namespace zypp
50 { /////////////////////////////////////////////////////////////////
51
52   ///////////////////////////////////////////////////////////////////
53   //
54   //    CLASS NAME : RepoManagerOptions
55   //
56   ///////////////////////////////////////////////////////////////////
57
58   RepoManagerOptions::RepoManagerOptions()
59   {
60     repoCachePath    = ZConfig::instance().repoCachePath();
61     repoRawCachePath = ZConfig::instance().repoMetadataPath();
62     knownReposPath   = ZConfig::instance().knownReposPath();
63   }
64
65   ////////////////////////////////////////////////////////////////////////////
66
67   /**
68     * \short Simple callback to collect the results
69     *
70     * Classes like RepoFileParser call the callback
71     * once per each repo in a file.
72     *
73     * Passing this functor as callback, you can collect
74     * all resuls at the end, without dealing with async
75     * code.
76     */
77     struct RepoCollector
78     {
79       RepoCollector()
80       {
81         MIL << endl;
82       }
83
84       ~RepoCollector()
85       {
86         MIL << endl;
87       }
88
89       bool collect( const RepoInfo &repo )
90       {
91         //MIL << "here in collector: " << repo.alias() << endl;
92         repos.push_back(repo);
93         //MIL << "added: " << repo.alias() << endl;
94         return true;
95       }
96
97       RepoInfoList repos;
98     };
99
100   ////////////////////////////////////////////////////////////////////////////
101
102   /**
103    * Reads RepoInfo's from a repo file.
104    *
105    * \param file pathname of the file to read.
106    */
107   static std::list<RepoInfo> repositories_in_file( const Pathname & file )
108   {
109     MIL << "repo file: " << file << endl;
110     RepoCollector collector;
111     parser::RepoFileReader parser( file, bind( &RepoCollector::collect, &collector, _1 ) );
112     return collector.repos;
113   }
114
115   ////////////////////////////////////////////////////////////////////////////
116
117   std::list<RepoInfo> readRepoFile(const Url & repo_file)
118    {
119      // no interface to download a specific file, using workaround:
120      //! \todo add MediaManager::provideFile(Url file_url) to easily access any file URLs? (no need for media access id or media_nr)
121      Url url(repo_file);
122      Pathname path(url.getPathName());
123      url.setPathName ("/");
124      MediaSetAccess access(url);
125      Pathname local = access.provideFile(path);
126
127      DBG << "reading repo file " << repo_file << ", local path: " << local << endl;
128
129      return repositories_in_file(local);
130    }
131
132   ////////////////////////////////////////////////////////////////////////////
133
134   /**
135    * \short List of RepoInfo's from a directory
136    *
137    * Goes trough every file in a directory and adds all
138    * RepoInfo's contained in that file.
139    *
140    * \param dir pathname of the directory to read.
141    */
142   static std::list<RepoInfo> repositories_in_dir( const Pathname &dir )
143   {
144     MIL << "directory " << dir << endl;
145     list<RepoInfo> repos;
146     list<Pathname> entries;
147     if ( filesystem::readdir( entries, Pathname(dir), false ) != 0 )
148       ZYPP_THROW(Exception("failed to read directory"));
149
150     for ( list<Pathname>::const_iterator it = entries.begin(); it != entries.end(); ++it )
151     {
152       list<RepoInfo> tmp = repositories_in_file( *it );
153       repos.insert( repos.end(), tmp.begin(), tmp.end() );
154
155       //std::copy( collector.repos.begin(), collector.repos.end(), std::back_inserter(repos));
156       //MIL << "ok" << endl;
157     }
158     return repos;
159   }
160
161   ////////////////////////////////////////////////////////////////////////////
162
163   static void assert_alias( const RepoInfo &info )
164   {
165     if (info.alias().empty())
166         ZYPP_THROW(RepoNoAliasException());
167   }
168
169   ////////////////////////////////////////////////////////////////////////////
170
171   static void assert_urls( const RepoInfo &info )
172   {
173     if (info.baseUrls().empty())
174         ZYPP_THROW(RepoNoUrlException());
175   }
176
177   ////////////////////////////////////////////////////////////////////////////
178
179   /**
180    * \short Calculates the raw cache path for a repository
181    */
182   static Pathname rawcache_path_for_repoinfo( const RepoManagerOptions &opt, const RepoInfo &info )
183   {
184     assert_alias(info);
185     return opt.repoRawCachePath + info.alias();
186   }
187
188   ///////////////////////////////////////////////////////////////////
189   //
190   //    CLASS NAME : RepoManager::Impl
191   //
192   ///////////////////////////////////////////////////////////////////
193
194   /**
195    * \short RepoManager implementation.
196    */
197   struct RepoManager::Impl
198   {
199     Impl( const RepoManagerOptions &opt )
200       : options(opt)
201     {
202
203     }
204
205     Impl()
206     {
207
208     }
209
210     RepoManagerOptions options;
211
212   public:
213     /** Offer default Impl. */
214     static shared_ptr<Impl> nullimpl()
215     {
216       static shared_ptr<Impl> _nullimpl( new Impl );
217       return _nullimpl;
218     }
219
220   private:
221     friend Impl * rwcowClone<Impl>( const Impl * rhs );
222     /** clone for RWCOW_pointer */
223     Impl * clone() const
224     { return new Impl( *this ); }
225   };
226   ///////////////////////////////////////////////////////////////////
227
228   /** \relates RepoManager::Impl Stream output */
229   inline std::ostream & operator<<( std::ostream & str, const RepoManager::Impl & obj )
230   {
231     return str << "RepoManager::Impl";
232   }
233
234   ///////////////////////////////////////////////////////////////////
235   //
236   //    CLASS NAME : RepoManager
237   //
238   ///////////////////////////////////////////////////////////////////
239
240   RepoManager::RepoManager( const RepoManagerOptions &opt )
241   : _pimpl( new Impl(opt) )
242   {}
243
244   ////////////////////////////////////////////////////////////////////////////
245
246   RepoManager::~RepoManager()
247   {}
248
249   ////////////////////////////////////////////////////////////////////////////
250
251   std::list<RepoInfo> RepoManager::knownRepositories() const
252   {
253     MIL << endl;
254
255     if ( PathInfo(_pimpl->options.knownReposPath).isExist() )
256     {
257       RepoInfoList repos = repositories_in_dir(_pimpl->options.knownReposPath);
258       for ( RepoInfoList::iterator it = repos.begin();
259             it != repos.end();
260             ++it )
261       {
262         // set the metadata path for the repo
263         Pathname metadata_path = rawcache_path_for_repoinfo(_pimpl->options, (*it));
264         (*it).setMetadataPath(metadata_path);
265       }
266       return repos;
267     }
268     else
269       return std::list<RepoInfo>();
270
271     MIL << endl;
272   }
273
274   ////////////////////////////////////////////////////////////////////////////
275
276   RepoStatus RepoManager::metadataStatus( const RepoInfo &info ) const
277   {
278     Pathname rawpath = rawcache_path_for_repoinfo( _pimpl->options, info );
279     RepoType repokind = info.type();
280     RepoStatus status;
281
282     switch ( repokind.toEnum() )
283     {
284       case RepoType::NONE_e:
285       // unknown, probe the local metadata
286         repokind = probe(rawpath.asUrl());
287       break;
288       default:
289       break;
290     }
291
292     switch ( repokind.toEnum() )
293     {
294       case RepoType::RPMMD_e :
295       {
296         status = RepoStatus( rawpath + "/repodata/repomd.xml");
297       }
298       break;
299
300       case RepoType::YAST2_e :
301       {
302         status = RepoStatus( rawpath + "/content");
303       }
304       break;
305
306       case RepoType::RPMPLAINDIR_e :
307       {
308         if ( PathInfo(Pathname(rawpath + "/cookie")).isExist() )
309           status = RepoStatus( rawpath + "/cookie");
310       }
311       break;
312
313       case RepoType::NONE_e :
314         // Return default RepoStatus in case of RepoType::NONE
315         // indicating it should be created?
316         // ZYPP_THROW(RepoUnknownTypeException());
317         break;
318     }
319     return status;
320   }
321
322   void RepoManager::refreshMetadata( const RepoInfo &info,
323                                      RawMetadataRefreshPolicy policy,
324                                      const ProgressData::ReceiverFnc & progress )
325   {
326     assert_alias(info);
327     assert_urls(info);
328
329     RepoStatus oldstatus;
330     RepoStatus newstatus;
331     // try urls one by one
332     for ( RepoInfo::urls_const_iterator it = info.baseUrlsBegin(); it != info.baseUrlsEnd(); ++it )
333     {
334       try
335       {
336         Url url(*it);
337
338         repo::RepoType repokind = info.type();
339
340         // if the type is unknown, try probing.
341         switch ( repokind.toEnum() )
342         {
343           case RepoType::NONE_e:
344             // unknown, probe it
345             repokind = probe(*it);
346           break;
347           default:
348           break;
349         }
350
351         Pathname rawpath = rawcache_path_for_repoinfo( _pimpl->options, info );
352         filesystem::assert_dir(rawpath);
353         oldstatus = metadataStatus(info);
354
355         // create temp dir as sibling of rawpath
356         filesystem::TmpDir tmpdir( filesystem::TmpDir::makeSibling( rawpath ) );
357
358         if ( ( repokind.toEnum() == RepoType::RPMMD_e ) ||
359              ( repokind.toEnum() == RepoType::YAST2_e ) )
360         {
361           MediaSetAccess media(url);
362           shared_ptr<repo::Downloader> downloader_ptr;
363
364           if ( repokind.toEnum() == RepoType::RPMMD_e )
365             downloader_ptr.reset(new yum::Downloader(info.path()));
366           else
367             downloader_ptr.reset( new susetags::Downloader(info.path()));
368
369           /**
370            * Given a downloader, sets the other repos raw metadata
371            * path as cache paths for the fetcher, so if another
372            * repo has the same file, it will not download it
373            * but copy it from the other repository
374            */
375           std::list<RepoInfo> repos = knownRepositories();
376           for ( std::list<RepoInfo>::const_iterator it = repos.begin();
377                 it != repos.end();
378                 ++it )
379           {
380             downloader_ptr->addCachePath(rawcache_path_for_repoinfo( _pimpl->options, *it ));
381           }
382
383           RepoStatus newstatus = downloader_ptr->status(media);
384           bool refresh = false;
385           if ( oldstatus.checksum() == newstatus.checksum() )
386           {
387             MIL << "repo has not changed" << endl;
388             if ( policy == RefreshForced )
389             {
390               MIL << "refresh set to forced" << endl;
391               refresh = true;
392             }
393           }
394           else
395           {
396             refresh = true;
397           }
398           if ( refresh )
399             downloader_ptr->download( media, tmpdir.path());
400           else
401             return;
402           // no error
403         }
404         else if ( repokind.toEnum() == RepoType::RPMPLAINDIR_e )
405         {
406           RepoStatus newstatus = parser::plaindir::dirStatus(url.getPathName());
407           bool refresh = false;
408           if ( oldstatus.checksum() == newstatus.checksum() )
409           {
410             MIL << "repo has not changed" << endl;
411             if ( policy == RefreshForced )
412             {
413               MIL << "refresh set to forced" << endl;
414               refresh = true;
415             }
416           }
417           else
418           {
419             refresh = true;
420           }
421
422           if ( refresh )
423           {
424             std::ofstream file(( tmpdir.path() + "/cookie").c_str());
425             if (!file) {
426               ZYPP_THROW (Exception( "Can't open " + tmpdir.path().asString() + "/cookie" ) );
427             }
428             file << url << endl;
429             file << newstatus.checksum() << endl;
430
431             file.close();
432           }
433           else
434             return;
435           // no error
436         }
437         else
438         {
439           ZYPP_THROW(RepoUnknownTypeException());
440         }
441
442         // ok we have the metadata, now exchange
443         // the contents
444         TmpDir oldmetadata( TmpDir::makeSibling( rawpath ) );
445         filesystem::rename( rawpath, oldmetadata.path() );
446         // move the just downloaded there
447         filesystem::rename( tmpdir.path(), rawpath );
448         // we are done.
449         return;
450       }
451       catch ( const Exception &e )
452       {
453         ZYPP_CAUGHT(e);
454         ERR << "Trying another url..." << endl;
455       }
456     } // for every url
457     ERR << "No more urls..." << endl;
458     ZYPP_THROW(RepoException("Cant refresh metadata"));
459   }
460
461   ////////////////////////////////////////////////////////////////////////////
462
463   void RepoManager::cleanMetadata( const RepoInfo &info,
464                                    const ProgressData::ReceiverFnc & progress )
465   {
466     filesystem::recursive_rmdir(rawcache_path_for_repoinfo(_pimpl->options, info));
467   }
468
469   void RepoManager::buildCache( const RepoInfo &info,
470                                 CacheBuildPolicy policy,
471                                 const ProgressData::ReceiverFnc & progressrcv )
472   {
473     ProgressData progress(100);
474     callback::SendReport<ProgressReport> report;
475     progress.sendTo( ProgressReportAdaptor( progressrcv, report ) );
476     progress.name(str::form(_("Building repository '%s' cache"), info.alias().c_str()));
477     progress.toMin();
478
479     assert_alias(info);
480     Pathname rawpath = rawcache_path_for_repoinfo(_pimpl->options, info);
481
482     cache::CacheStore store(_pimpl->options.repoCachePath);
483
484     RepoStatus raw_metadata_status = metadataStatus(info);
485     if ( raw_metadata_status.empty() )
486     {
487       ZYPP_THROW(RepoMetadataException(info));
488     }
489
490     if ( store.isCached( info.alias() ) )
491     {
492       MIL << info.alias() << " is already cached." << endl;
493       data::RecordId id = store.lookupRepository(info.alias());
494       RepoStatus cache_status = store.repositoryStatus(id);
495
496       if ( cache_status.checksum() == raw_metadata_status.checksum() )
497       {
498         MIL << info.alias() << " cache is up to date with metadata." << endl;
499         if ( policy == BuildIfNeeded ) {
500           progress.toMax();
501           return;
502         }
503         else {
504           MIL << info.alias() << " cache rebuild is forced" << endl;
505         }
506       }
507       MIL << info.alias() << " cleaning cache..." << endl;
508       store.cleanRepository(id);
509     }
510
511     MIL << info.alias() << " building cache..." << endl;
512     data::RecordId id = store.lookupOrAppendRepository(info.alias());
513     // do we have type?
514     repo::RepoType repokind = info.type();
515
516     // if the type is unknown, try probing.
517     switch ( repokind.toEnum() )
518     {
519       case RepoType::NONE_e:
520         // unknown, probe the local metadata
521         repokind = probe(rawpath.asUrl());
522       break;
523       default:
524       break;
525     }
526
527     CombinedProgressData subprogrcv( progress, 100);
528
529     switch ( repokind.toEnum() )
530     {
531       case RepoType::RPMMD_e :
532       {
533         parser::yum::RepoParser parser(id, store, parser::yum::RepoParserOpts(), subprogrcv);
534         parser.parse(rawpath);
535           // no error
536       }
537       break;
538       case RepoType::YAST2_e :
539       {
540         parser::susetags::RepoParser parser(id, store, subprogrcv);
541         parser.parse(rawpath);
542         // no error
543       }
544       break;
545       case RepoType::RPMPLAINDIR_e :
546       {
547         InputStream is(rawpath + "cookie");
548         string buffer;
549         getline( is.stream(), buffer);
550         Url url(buffer);
551         parser::plaindir::RepoParser parser(id, store, subprogrcv);
552         parser.parse(url.getPathName());
553       }
554       break;
555       default:
556         ZYPP_THROW(RepoUnknownTypeException());
557     }
558
559     // update timestamp and checksum
560     store.updateRepositoryStatus(id, raw_metadata_status);
561
562     MIL << "Commit cache.." << endl;
563     store.commit();
564     progress.toMax();
565   }
566
567   ////////////////////////////////////////////////////////////////////////////
568
569   repo::RepoType RepoManager::probe( const Url &url ) const
570   {
571     if ( url.getScheme() == "dir" && ! PathInfo( url.getPathName() ).isDir() )
572     {
573       // Handle non existing local directory in advance, as
574       // MediaSetAccess does not support it.
575       return repo::RepoType::NONE;
576     }
577
578     MediaSetAccess access(url);
579     if ( access.doesFileExist("/repodata/repomd.xml") )
580       return repo::RepoType::RPMMD;
581     if ( access.doesFileExist("/content") )
582       return repo::RepoType::YAST2;
583
584     // if it is a local url of type dir
585     if ( (! media::MediaManager::downloads(url)) && ( url.getScheme() == "dir" ) )
586     {
587       Pathname path = Pathname(url.getPathName());
588       if ( PathInfo(path).isDir() )
589       {
590         // allow empty dirs for now
591         return repo::RepoType::RPMPLAINDIR;
592       }
593     }
594
595     return repo::RepoType::NONE;
596   }
597
598   ////////////////////////////////////////////////////////////////////////////
599
600   void RepoManager::cleanCache( const RepoInfo &info,
601                                 const ProgressData::ReceiverFnc & progressrcv )
602   {
603     ProgressData progress(100);
604     callback::SendReport<ProgressReport> report;
605     progress.sendTo( ProgressReportAdaptor( progressrcv, report ) );
606     progress.name(str::form(_("Cleaning repository '%s' cache"), info.alias().c_str()));
607     progress.toMin();
608
609     cache::CacheStore store(_pimpl->options.repoCachePath);
610
611     data::RecordId id = store.lookupRepository(info.alias());
612     store.cleanRepository(id);
613     store.commit();
614   }
615
616   ////////////////////////////////////////////////////////////////////////////
617
618   bool RepoManager::isCached( const RepoInfo &info ) const
619   {
620     cache::CacheStore store(_pimpl->options.repoCachePath);
621     return store.isCached(info.alias());
622   }
623
624   RepoStatus RepoManager::cacheStatus( const RepoInfo &info ) const
625   {
626     cache::CacheStore store(_pimpl->options.repoCachePath);
627     data::RecordId id = store.lookupRepository(info.alias());
628     RepoStatus cache_status = store.repositoryStatus(id);
629     return cache_status;
630   }
631
632   Repository RepoManager::createFromCache( const RepoInfo &info,
633                                            const ProgressData::ReceiverFnc & progressrcv )
634   {
635     callback::SendReport<ProgressReport> report;
636     ProgressData progress;
637     progress.sendTo(ProgressReportAdaptor( progressrcv, report ));
638     //progress.sendTo( progressrcv );
639     progress.name(str::form(_("Reading repository '%s' cache"), info.alias().c_str()));
640     
641     cache::CacheStore store(_pimpl->options.repoCachePath);
642
643     if ( ! store.isCached( info.alias() ) )
644       ZYPP_THROW(RepoNotCachedException());
645
646     MIL << "Repository " << info.alias() << " is cached" << endl;
647
648     data::RecordId id = store.lookupRepository(info.alias());
649
650     repo::cached::RepoOptions opts( info, _pimpl->options.repoCachePath, id );
651     opts.readingResolvablesProgress = progressrcv;
652     repo::cached::RepoImpl::Ptr repoimpl =
653         new repo::cached::RepoImpl( opts );
654
655     repoimpl->resolvables();
656     // read the resolvables from cache
657     return Repository(repoimpl);
658   }
659
660   ////////////////////////////////////////////////////////////////////////////
661
662   /**
663    * Generate a non existing filename in a directory, using a base
664    * name. For example if a directory contains 3 files
665    *
666    * |-- bar
667    * |-- foo
668    * `-- moo
669    *
670    * If you try to generate a unique filename for this directory,
671    * based on "ruu" you will get "ruu", but if you use the base
672    * "foo" you will get "foo_1"
673    *
674    * \param dir Directory where the file needs to be unique
675    * \param basefilename string to base the filename on.
676    */
677   static Pathname generate_non_existing_name( const Pathname &dir,
678                                               const std::string &basefilename )
679   {
680     string final_filename = basefilename;
681     int counter = 1;
682     while ( PathInfo(dir + final_filename).isExist() )
683     {
684       final_filename = basefilename + "_" + str::numstring(counter);
685       counter++;
686     }
687     return dir + Pathname(final_filename);
688   }
689
690   ////////////////////////////////////////////////////////////////////////////
691
692   /**
693    * \short Generate a related filename from a repo info
694    *
695    * From a repo info, it will try to use the alias as a filename
696    * escaping it if necessary. Other fallbacks can be added to
697    * this function in case there is no way to use the alias
698    */
699   static std::string generate_filename( const RepoInfo &info )
700   {
701     std::string fnd="/";
702     std::string rep="_";
703     std::string filename = info.alias();
704     // replace slashes with underscores
705     size_t pos = filename.find(fnd);
706     while(pos!=string::npos)
707     {
708       filename.replace(pos,fnd.length(),rep);
709       pos = filename.find(fnd,pos+rep.length());
710     }
711     filename = Pathname(filename).extend(".repo").asString();
712     MIL << "generating filename for repo [" << info.alias() << "] : '" << filename << "'" << endl;
713     return filename;
714   }
715
716
717   ////////////////////////////////////////////////////////////////////////////
718
719   void RepoManager::addRepository( const RepoInfo &info,
720                                    const ProgressData::ReceiverFnc & progressrcv )
721   {
722     assert_alias(info);
723
724     ProgressData progress(100);
725     callback::SendReport<ProgressReport> report;
726     progress.sendTo( ProgressReportAdaptor( progressrcv, report ) );
727     progress.name(str::form(_("Adding repository '%s'"), info.alias().c_str()));
728     progress.toMin();
729
730     std::list<RepoInfo> repos = knownRepositories();
731     for ( std::list<RepoInfo>::const_iterator it = repos.begin();
732           it != repos.end();
733           ++it )
734     {
735       if ( info.alias() == (*it).alias() )
736         ZYPP_THROW(RepoAlreadyExistsException(info.alias()));
737     }
738
739     progress.set(50);
740
741     // assert the directory exists
742     filesystem::assert_dir(_pimpl->options.knownReposPath);
743
744     Pathname repofile = generate_non_existing_name(_pimpl->options.knownReposPath,
745                                                     generate_filename(info));
746     // now we have a filename that does not exists
747     MIL << "Saving repo in " << repofile << endl;
748
749     std::ofstream file(repofile.c_str());
750     if (!file) {
751       ZYPP_THROW (Exception( "Can't open " + repofile.asString() ) );
752     }
753
754     info.dumpRepoOn(file);
755     progress.toMax();
756     MIL << "done" << endl;
757   }
758
759   void RepoManager::addRepositories( const Url &url,
760                                      const ProgressData::ReceiverFnc & progressrcv )
761   {
762     std::list<RepoInfo> knownrepos = knownRepositories();
763     std::list<RepoInfo> repos = readRepoFile(url);
764     for ( std::list<RepoInfo>::const_iterator it = repos.begin();
765           it != repos.end();
766           ++it )
767     {
768       // look if the alias is in the known repos.
769       for ( std::list<RepoInfo>::const_iterator kit = knownrepos.begin();
770           kit != knownrepos.end();
771           ++kit )
772       {
773         if ( (*it).alias() == (*kit).alias() )
774         {
775           ERR << "To be added repo " << (*it).alias() << " conflicts with existing repo " << (*kit).alias() << endl;
776           ZYPP_THROW(RepoAlreadyExistsException((*it).alias()));
777         }
778       }
779     }
780
781     string filename = Pathname(url.getPathName()).basename();
782
783     if ( filename == Pathname() )
784       ZYPP_THROW(RepoException("Invalid repo file name at " + url.asString() ));
785
786     // assert the directory exists
787     filesystem::assert_dir(_pimpl->options.knownReposPath);
788
789     Pathname repofile = generate_non_existing_name(_pimpl->options.knownReposPath, filename);
790     // now we have a filename that does not exists
791     MIL << "Saving " << repos.size() << " repo" << ( repos.size() ? "s" : "" ) << " in " << repofile << endl;
792
793     std::ofstream file(repofile.c_str());
794     if (!file) {
795       ZYPP_THROW (Exception( "Can't open " + repofile.asString() ) );
796     }
797
798     for ( std::list<RepoInfo>::const_iterator it = repos.begin();
799           it != repos.end();
800           ++it )
801     {
802       MIL << "Saving " << (*it).alias() << endl;
803       (*it).dumpRepoOn(file);
804     }
805     MIL << "done" << endl;
806   }
807
808   ////////////////////////////////////////////////////////////////////////////
809
810   void RepoManager::removeRepository( const RepoInfo & info,
811                                       const ProgressData::ReceiverFnc & progressrcv)
812   {
813     MIL << "Going to delete repo " << info.alias() << endl;
814
815     std::list<RepoInfo> repos = knownRepositories();
816     for ( std::list<RepoInfo>::const_iterator it = repos.begin();
817           it != repos.end();
818           ++it )
819     {
820       // they can be the same only if the provided is empty, that means
821       // the provided repo has no alias
822       // then skip
823       if ( (!info.alias().empty()) && ( info.alias() != (*it).alias() ) )
824         continue;
825
826       // TODO match by url
827
828       // we have a matcing repository, now we need to know
829       // where it does come from.
830       RepoInfo todelete = *it;
831       if (todelete.filepath().empty())
832       {
833         ZYPP_THROW(RepoException("Can't figure where the repo is stored"));
834       }
835       else
836       {
837         // figure how many repos are there in the file:
838         std::list<RepoInfo> filerepos = repositories_in_file(todelete.filepath());
839         if ( (filerepos.size() == 1) && ( filerepos.front().alias() == todelete.alias() ) )
840         {
841           // easy, only this one, just delete the file
842           if ( filesystem::unlink(todelete.filepath()) != 0 )
843           {
844             ZYPP_THROW(RepoException("Can't delete " + todelete.filepath().asString()));
845           }
846           MIL << todelete.alias() << " sucessfully deleted." << endl;
847         }
848         else
849         {
850           // there are more repos in the same file
851           // write them back except the deleted one.
852           //TmpFile tmp;
853           //std::ofstream file(tmp.path().c_str());
854
855           // assert the directory exists
856           filesystem::assert_dir(todelete.filepath().dirname());
857
858           std::ofstream file(todelete.filepath().c_str());
859           if (!file) {
860             //ZYPP_THROW (Exception( "Can't open " + tmp.path().asString() ) );
861             ZYPP_THROW (Exception( "Can't open " + todelete.filepath().asString() ) );
862           }
863           for ( std::list<RepoInfo>::const_iterator fit = filerepos.begin();
864                 fit != filerepos.end();
865                 ++fit )
866           {
867             if ( (*fit).alias() != todelete.alias() )
868               (*fit).dumpRepoOn(file);
869           }
870         }
871
872         // now delete it from cache
873         cache::CacheStore store(_pimpl->options.repoCachePath);
874
875         if ( store.isCached( todelete.alias() ) ) {
876           MIL << "repository was cached. cleaning cache" << endl;
877           store.cleanRepository(todelete.alias());
878           store.commit();
879         }
880
881         MIL << todelete.alias() << " sucessfully deleted." << endl;
882         return;
883       } // else filepath is empty
884
885     }
886     // should not be reached on a sucess workflow
887     ZYPP_THROW(RepoNotFoundException(info));
888   }
889
890   ////////////////////////////////////////////////////////////////////////////
891
892   void RepoManager::modifyRepository( const std::string &alias,
893                                       const RepoInfo & newinfo,
894                                       const ProgressData::ReceiverFnc & progressrcv )
895   {
896     RepoInfo toedit = getRepositoryInfo(alias);
897
898     if (toedit.filepath().empty())
899     {
900       ZYPP_THROW(RepoException("Can't figure where the repo is stored"));
901     }
902     else
903     {
904       // figure how many repos are there in the file:
905       std::list<RepoInfo> filerepos = repositories_in_file(toedit.filepath());
906
907       // there are more repos in the same file
908       // write them back except the deleted one.
909       //TmpFile tmp;
910       //std::ofstream file(tmp.path().c_str());
911
912       // assert the directory exists
913       filesystem::assert_dir(toedit.filepath().dirname());
914
915       std::ofstream file(toedit.filepath().c_str());
916       if (!file) {
917         //ZYPP_THROW (Exception( "Can't open " + tmp.path().asString() ) );
918         ZYPP_THROW (Exception( "Can't open " + toedit.filepath().asString() ) );
919       }
920       for ( std::list<RepoInfo>::const_iterator fit = filerepos.begin();
921             fit != filerepos.end();
922             ++fit )
923       {
924           // if the alias is different, dump the original
925           // if it is the same, dump the provided one
926           if ( (*fit).alias() != toedit.alias() )
927             (*fit).dumpRepoOn(file);
928           else
929             newinfo.dumpRepoOn(file);
930       }
931     }
932   }
933
934   ////////////////////////////////////////////////////////////////////////////
935
936   RepoInfo RepoManager::getRepositoryInfo( const std::string &alias,
937                                            const ProgressData::ReceiverFnc & progressrcv )
938   {
939     std::list<RepoInfo> repos = knownRepositories();
940     for ( std::list<RepoInfo>::const_iterator it = repos.begin();
941           it != repos.end();
942           ++it )
943     {
944       if ( (*it).alias() == alias )
945         return *it;
946     }
947     RepoInfo info;
948     info.setAlias(info.alias());
949     ZYPP_THROW(RepoNotFoundException(info));
950   }
951
952   ////////////////////////////////////////////////////////////////////////////
953
954   RepoInfo RepoManager::getRepositoryInfo( const Url & url,
955                                            const url::ViewOption & urlview,
956                                            const ProgressData::ReceiverFnc & progressrcv )
957   {
958     std::list<RepoInfo> repos = knownRepositories();
959     for ( std::list<RepoInfo>::const_iterator it = repos.begin();
960           it != repos.end();
961           ++it )
962     {
963       for(RepoInfo::urls_const_iterator urlit = (*it).baseUrlsBegin();
964           urlit != (*it).baseUrlsEnd();
965           ++urlit)
966       {
967         if ((*urlit).asString(urlview) == url.asString(urlview))
968           return *it;
969       }
970     }
971     RepoInfo info;
972     info.setAlias(info.alias());
973     info.setBaseUrl(url);
974     ZYPP_THROW(RepoNotFoundException(info));
975   }
976
977   ////////////////////////////////////////////////////////////////////////////
978
979   std::ostream & operator<<( std::ostream & str, const RepoManager & obj )
980   {
981     return str << *obj._pimpl;
982   }
983
984   /////////////////////////////////////////////////////////////////
985 } // namespace zypp
986 ///////////////////////////////////////////////////////////////////