InstTarget.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                                                                      |
|                      __   __    ____ _____ ____                      |
|                      \ \ / /_ _/ ___|_   _|___ \                     |
|                       \ V / _` \___ \ | |   __) |                    |
|                        | | (_| |___) || |  / __/                     |
|                        |_|\__,_|____/ |_| |_____|                    |
|                                                                      |
|                               core system                            |
|                                                        (C) SuSE GmbH |
\----------------------------------------------------------------------/

   File:       InstTarget.h

   Author:     Michael Andres <ma@suse.de>
   Maintainer: Michael Andres <ma@suse.de>

   Purpose:     Class for installation target
                It provides access to the installation target
                and shares some API calls with InstSrc, esp.
                - selection information
                - package information
                - patch information
                but does not report about installable but installed
                selections, packages, or patches.

                Additionally, the InstTarget can also change packages,
                selections, and patches, by installing or removing them.

/-*/
#ifndef InstTarget_h
#define InstTarget_h

#include <iosfwd>
#include <list>
#include <set>
#include <string>

#include <y2util/Pathname.h>
#include <y2util/FSize.h>

#include <y2pm/PMError.h>

#include <y2pm/MediaAccessPtr.h>        // physical media access class
#include <y2pm/PkgArch.h>
#include <y2pm/PMPackagePtr.h>
#include <y2pm/PMSelectionPtr.h>
#include <y2pm/PMYouPatchPtr.h>
#include <y2pm/InstData.h>       // InstTarget implements InstData

#include <y2pm/RpmDb.h>               // InstTarget is tied to RpmDb atm
#include <y2pm/InstTargetProdDBPtr.h> // Installed Products
#include <y2pm/InstSrcDescrPtr.h>
#include <y2pm/InstTargetSelDBPtr.h>  // Installed Selections
#include <y2pm/PkgDu.h>

//
//      CLASS NAME : InstTarget
class InstTarget: public CountedRep, public InstData {
    REP_BODY(InstTarget);

  public:

    typedef class InstTargetError Error;

    // General interface

  private:

    Pathname _rootdir;

    RpmDbPtr _rpmdb;

    InstTargetProdDBPtr _proddb;

    InstTargetSelDBPtr _seldb;

  private:

    friend class Y2PM;
    // no parameters here since Y2PM creates it on first access
    // and there's no way to pass parameters -> see init()
    InstTarget();
    ~InstTarget();

    PMError init( const Pathname & rootpath );

  public:

    static PkgArch baseArch();

    const Pathname & rootdir() const { return _rootdir; }

    bool initialized() const { return( ! _rootdir.empty() ); }

    bool needsUpdate() const;

    PMError bringIntoCleanState();

    virtual const std::list<PMPackagePtr> & getPackages() const;

    virtual const std::vector<PMYouPatchPtr> & getPatches() const;

    // Package related interface

  private:

    unsigned _rpminstflags;

    unsigned _rpmremoveflags;

  public:

    typedef enum RpmDb::RpmInstFlag InstFlag;

    typedef enum RpmDb::checkPackageResult checkPackageResult;

    //-----------------------------
    // package install / remove

    bool setInstallationLogfile(const std::string& logfile);

    void setBackupPath (const Pathname& path);

    void createPackageBackups(bool yes);

    Pathname getBackupPath (void);

    void setPkgInstFlags(unsigned flags);

    unsigned getPkgInstFlags() const;

    void setPkgRemoveFlags(unsigned flags);

    unsigned getPkgRemoveFlags() const;

    PMError installPackage (const Pathname& filename, unsigned flags = 0);

    PMError installPackages (const std::list<Pathname>& filenames, unsigned flags = 0);

    PMError removePackage(const std::string & name_r, unsigned flags = 0);
    PMError removePackage(constPMPackagePtr package, unsigned flags = 0);

    PMError removePackages(const std::list<std::string>& names_r, unsigned flags = 0);
    PMError removePackages(const std::list<PMPackagePtr>& packages, unsigned flags = 0);

  public:
    //
    // RPM database public keys
    //

    PMError importPubkey( const Pathname & pubkey_r ) { return _rpmdb->importPubkey( pubkey_r ); }

    PMError importPubkey( const Pathname & keyring_r, const std::string & keyname_r ) { return _rpmdb->importPubkey( keyring_r, keyname_r ); }

    std::set<PkgEdition> pubkeys() const { return _rpmdb->pubkeys(); }

  public:
    //
    // Direct RPM database retrieval forwarded to RpmDb
    //

    bool hasFile( const std::string & file_r ) const { return _rpmdb->hasFile( file_r ); }

    bool hasProvides( const std::string & tag_r ) const { return _rpmdb->hasProvides( tag_r ); }

    bool hasRequiredBy( const std::string & tag_r ) const { return _rpmdb->hasRequiredBy( tag_r ); }

    bool hasConflicts( const std::string & tag_r ) const { return _rpmdb->hasConflicts( tag_r ); }

    bool hasPackage( const PkgName & name_r ) const { return _rpmdb->hasPackage( name_r ); }

    void traceFileRel( const PkgRelation & rel_r ) { _rpmdb->traceFileRel( rel_r ); }


    bool isProvided (const std::string& tag) { return hasProvides(tag); }
    bool isInstalled (const std::string& name) { return hasPackage(PkgName(name)); }

    // Patch related interface
  private:

      mutable std::vector<PMYouPatchPtr> _patches;
      mutable bool _patchesInitialized;

  public:

    PMError installPatch( const Pathname &filename );

    PMError executeScript( const Pathname &scriptname );

    // Product related interface
  public:

    bool mayAccessProducts() const;

    const std::list<constInstSrcDescrPtr> & getProducts() const;

    bool isInstalledProduct( const constInstSrcDescrPtr & isd_r ) const;

    PMError installProduct( const constInstSrcDescrPtr & isd_r );

    PMError removeProduct( const constInstSrcDescrPtr & isd_r );


    // Selection related interface
  public:

    bool mayAccessSelections() const;

    virtual const std::list<PMSelectionPtr> & getSelections() const;

    bool isInstalledSelection( const Pathname & selfile_r ) const;

    PMError installSelection( const Pathname & selfile_r );

    PMError removeSelection( const Pathname & selfile_r );


    //
    // Disk usage calculation.
    //
  public:

    std::set<PkgDuMaster::MountPoint> getMountPoints() const;
};


#endif // InstTarget_h

---