SuseTagsImpl.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_SOURCE_SUSETAGS_SUSETAGSIMPL_H
#define ZYPP_SOURCE_SUSETAGS_SUSETAGSIMPL_H

#include <iosfwd>
#include <string>

#include "zypp/Pathname.h"
#include "zypp/source/SourceImpl.h"
#include "zypp/base/DefaultFalseBool.h"
#include "zypp/Product.h"
#include "zypp/CheckSum.h"
#include "zypp/source/susetags/SuseTagsProductImpl.h"
#include "zypp/source/susetags/SuseTagsPackageImpl.h"
#include "zypp/TmpPath.h"

using namespace zypp::filesystem;

namespace zypp
{ 

  namespace source
  { 

    namespace susetags
    { 

      struct SuseTagsPackageImplData
      {
        SuseTagsPackageImplData()
        {
        }

        TranslatedText _summary;
        TranslatedText _description;
        TranslatedText _insnotify;
        TranslatedText _delnotify;
        TranslatedText _license_to_confirm;
        std::list<std::string> _authors;
      };

      //
      //        CLASS NAME : SuseTagsImpl
      //
      class SuseTagsImpl : public SourceImpl
      {
      public:
        typedef intrusive_ptr<SuseTagsImpl>       Ptr;
        typedef intrusive_ptr<const SuseTagsImpl> constPtr;

      public:
        SuseTagsImpl();
        ~SuseTagsImpl();

      public:
        virtual void createResolvables(Source_Ref source_r);

        virtual ResStore provideResolvables(Source_Ref source_r, zypp::Resolvable::Kind kind);

        virtual std::string type(void) const
        { return typeString(); }

        static std::string typeString(void)
        { return "YaST"; }
        virtual Date timestamp() const;
        virtual unsigned numberOfMedia(void) const;
        virtual std::string vendor (void) const;
        virtual const std::list<Pathname> publicKeys();
        virtual std::string unique_id (void) const;

        Pathname sourceDir( const std::string & dir );
        virtual void storeMetadata(const Pathname & cache_dir_r);

        virtual media::MediaVerifierRef verifier(media::MediaNr media_nr);

      protected:
        virtual std::ostream & dumpOn( std::ostream & str ) const;
        void initCacheDir(const Pathname & cache_dir_r);
        bool cacheExists() const;
      private:
        virtual void factoryInit();
        
        const Pathname metadataRoot() const;
        const Pathname contentFile() const;
        const Pathname contentFileKey() const;
        const Pathname contentFileSignature() const;
        const Pathname descrDir() const;
        const Pathname mediaFile() const;
        
        void saveMetadataTo(const Pathname & dir_r);
        
        const Pathname mediaDescrDir() const;
        
        const Pathname dataDir() const;
        
        void readContentFile(const Pathname &p);
         
        void checkMetadataChecksums(const Pathname &dir) const;
        
        void readMediaFile(const Pathname &p);
        
        TmpDir downloadMetadata();
        bool downloadNeeded(const Pathname &localdir);
        
        void provideProducts(Source_Ref source_r, ResStore& store);
        void providePackages(Source_Ref source_r, ResStore& store);
        void provideSelections(Source_Ref source_r, ResStore& store);
        void provideSelection(Source_Ref source_r, ResStore& store);
        void providePatterns(Source_Ref source_r, ResStore& store);

        bool verifyChecksumsMode() const;

        void verifyFile( const Pathname &path, const std::string &key) const;

        unsigned _media_count;

        // data dir we are using
        // depends if we are on media or
        // cache
        Pathname _data_dir;

        // descr dir on media.
        // we need it if we refresh
        // already running from cache
        Pathname _media_descr_dir;

        // in case we dont have cache
        TmpDir _tmp_metadata_dir;
        
        std::string _vendor;
        std::string _media_id;
        detail::ResImplTraits<SuseTagsProductImpl>::Ptr _prodImpl;
        Product::Ptr _product;
        public:

        // shared data between packages with same NVRA
        std::map<NVRA, SuseTagsPackageImplData> _package_data;
        // list of packages which depend on another package for its data
        std::map<NVRA, DefaultFalseBool> _is_shared;
        // list of packages which provide data to another package
        std::map<NVRA, DefaultFalseBool> _provides_shared_data;

        // list of translation files
        std::list<std::string> _pkg_translations;
      };

    } // namespace susetags

    using susetags::SuseTagsImpl;

  } // namespace source
} // namespace zypp
#endif // ZYPP_SOURCE_SUSETAGS_SUSETAGSIMPL_H

---