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/base/NonCopyable.h>
#include <zypp/base/PtrTypes.h>
#include <zypp/PoolItem.h>
#include <zypp/ZYppCommit.h>

#include <zypp/Pathname.h>
#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:
      typedef std::list<PoolItem> PoolItemList;

      typedef std::set<PoolItem> PoolItemSet;

    public:
      TargetImpl(const Pathname & root_r = "/", bool doRebuild_r = false );
      virtual ~TargetImpl();

#ifdef ANONYMOUS_ID

      void createAnonymousId() const;

      void createLastDistributionFlavorCache() const;
#endif

    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 );

      virtual std::ostream & dumpOn( std::ostream & str ) const
      {
        return str << "TargetImpl";
      }

      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 );

#ifdef ANONYMOUS_ID

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

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

      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 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