TargetImpl.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_TARGET_TARGETIMPL_H
#define ZYPP_TARGET_TARGETIMPL_H
 
#include <iosfwd>
#include <set>
 
#include <zypp/base/ReferenceCounted.h>
#include <zypp-core/base/NonCopyable.h>
#include <zypp-core/base/PtrTypes.h>
#include <zypp/PoolItem.h>
#include <zypp/ZYppCommit.h>
 
#include <zypp-core/Pathname.h>
#include <zypp-core/fs/WatchFile>
#include <zypp/Target.h>
#include <zypp/target/rpm/RpmDb.h>
#include <zypp/target/TargetException.h>
#include <zypp/target/RequestedLocalesFile.h>
#include <zypp/target/SolvIdentFile.h>
#include <zypp/target/HardLocksFile.h>
#include <zypp/ManagedFile.h>
#include <zypp/VendorAttr.h>

namespace zypp
{ 
  namespace target
  { 
 
    DEFINE_PTR_TYPE(TargetImpl);
    class CommitPackageCache;

    //
    //  CLASS NAME : TargetImpl
    //
    class TargetImpl : public base::ReferenceCounted, private base::NonCopyable
    {
      friend std::ostream & operator<<( std::ostream & str, const TargetImpl & obj );
 
    public:
      using PoolItemList = std::list<PoolItem>;

      using PoolItemSet = std::set<PoolItem>;
 
    public:
      TargetImpl(const Pathname & root_r = "/", bool doRebuild_r = false );
      ~TargetImpl() override;

      void createAnonymousId() const;

      void createLastDistributionFlavorCache() const;

    private:
      Pathname defaultSolvfilesPath() const;

      Pathname solvfilesPath() const
      { return solvfilesPathIsTemp() ? _tmpSolvfilesPath : defaultSolvfilesPath(); }

      bool solvfilesPathIsTemp() const
      { return ! _tmpSolvfilesPath.empty(); }
 
      Pathname _tmpSolvfilesPath;
 
    public:
      void load( bool force = true );
 
      void unload();
 
      void reload();
 
      void clearCache();
 
      bool buildCache();
 
    public:

      Pathname root() const
      { return _root; }

      Pathname home() const
      { return home( _root ); }
 
      static Pathname home( const Pathname & root_r )
      { return root_r / "/var/lib/zypp"; }

      ZYppCommitResult commit( ResPool pool_r, const ZYppCommitPolicy & policy_r );

      void installSrcPackage( const SrcPackage_constPtr & srcPackage_r );

      ManagedFile provideSrcPackage( const SrcPackage_constPtr & srcPackage_r );

      std::ostream & dumpOn( std::ostream & str ) const override
      { return str << "Target(" << root() << ")"; }

      rpm::RpmDb & rpm();

      bool providesFile (const std::string & path_str, const std::string & name_str) const;

      std::string whoOwnsFile (const std::string & path_str) const
      { return _rpm.whoOwnsFile (path_str); }

      Product::constPtr baseProduct() const;

      LocaleSet requestedLocales() const
      { return _requestedLocalesFile.locales(); }

      static LocaleSet requestedLocales( const Pathname & root_r );

      void updateAutoInstalled();

      std::string targetDistribution() const;
      static std::string targetDistribution( const Pathname & root_r );

      std::string targetDistributionRelease() const;
      static std::string targetDistributionRelease( const Pathname & root_r );

      std::string targetDistributionFlavor() const;
      static std::string targetDistributionFlavor( const Pathname & root_r );

      Target::DistributionLabel distributionLabel() const;
      static Target::DistributionLabel distributionLabel( const Pathname & root_r );

      std::string distributionVersion() const;
      static std::string distributionVersion( const Pathname & root_r );

      std::string distributionFlavor() const;
      static std::string distributionFlavor( const Pathname & root_r );

      std::string anonymousUniqueId() const;
      static std::string anonymousUniqueId( const Pathname & root_r );

      const VendorAttr & vendorAttr() const
      { return _vendorAttr; }

      void vendorAttr( VendorAttr vendorAttr_r );
 
  public:
    private:
      void commit( const ZYppCommitPolicy & policy_r,
                   CommitPackageCache & packageCache_r,
                   ZYppCommitResult & result_r );

      void commitInSingleTransaction( const ZYppCommitPolicy & policy_r,
        CommitPackageCache & packageCache_r,
        ZYppCommitResult & result_r );
 

      void commitFindFileConflicts( const ZYppCommitPolicy & policy_r, ZYppCommitResult & result_r );
    protected:
      Pathname _root;
      rpm::RpmDb _rpm;
      RequestedLocalesFile _requestedLocalesFile;
      SolvIdentFile _autoInstalledFile;
      HardLocksFile _hardLocksFile;
      mutable WatchFile _baseproductWatcher;
      mutable std::string _distributionVersion;
      VendorAttr _vendorAttr;
    };


    inline std::ostream & operator<<( std::ostream & str, const TargetImpl & obj )
    {
      return obj.dumpOn( str );
    }

  } // namespace target
} // namespace zypp
#endif // ZYPP_TARGET_TARGETIMPL_H