RpmDb.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
// -*- C++ -*-

#ifndef ZYPP_TARGET_RPM_RPMDB_H
#define ZYPP_TARGET_RPM_RPMDB_H

#include <iosfwd>
#include <list>
#include <vector>
#include <string>

#include "zypp/Pathname.h"
#include "zypp/ExternalProgram.h"

#include "zypp/Package.h"
#include "zypp/KeyRing.h"

#include "zypp/target/rpm/RpmHeader.h"
#include "zypp/target/rpm/RpmCallbacks.h"
#include "zypp/ZYppCallbacks.h"

namespace zypp
{
namespace target
{
namespace rpm
{

//
//      CLASS NAME : RpmDb
class RpmDb : public base::ReferenceCounted, private base::NonCopyable
{
public:

  typedef class InstTargetError Error;

  //
  // INITALISATION
  //
private:

  enum DbStateInfoBits {
    DbSI_NO_INIT        = 0x0000,
    DbSI_HAVE_V4        = 0x0001,
    DbSI_MADE_V4        = 0x0002,
    DbSI_MODIFIED_V4    = 0x0004,
    DbSI_HAVE_V3        = 0x0008,
    DbSI_HAVE_V3TOV4    = 0x0010,
    DbSI_MADE_V3TOV4    = 0x0020
  };

  friend std::ostream & operator<<( std::ostream & str, const DbStateInfoBits & obj );

  void dbsi_set( DbStateInfoBits & val_r, const unsigned & bits_r ) const
  {
    val_r = (DbStateInfoBits)(val_r | bits_r);
  }
  void dbsi_clr( DbStateInfoBits & val_r, const unsigned & bits_r ) const
  {
    val_r = (DbStateInfoBits)(val_r & ~bits_r);
  }
  bool dbsi_has( const DbStateInfoBits & val_r, const unsigned & bits_r ) const
  {
    return( (val_r & bits_r) == bits_r );
  }

  DbStateInfoBits _dbStateInfo;

  Pathname _root;

  Pathname _dbPath;

  void internal_initDatabase( const Pathname & root_r, const Pathname & dbPath_r,
                              DbStateInfoBits & info_r );

  static void removeV4( const Pathname & dbdir_r, bool v3backup_r );

  static void removeV3( const Pathname & dbdir_r, bool v3backup_r );

  void modifyDatabase();

public:

  RpmDb();

  ~RpmDb();

  Date timestamp() const;

  const Pathname & root() const
  {
    return _root;
  }

  const Pathname & dbPath() const
  {
    return _dbPath;
  }

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

  void initDatabase( Pathname root_r = Pathname(),
                     Pathname dbPath_r = Pathname() );

  void closeDatabase();

  void rebuildDatabase();

  void importPubkey( const PublicKey & pubkey_r );

  std::list<PublicKey> pubkeys() const;

  std::set<Edition> pubkeyEditions() const;

  //
  // Cached RPM database retrieval via librpm.
  //
private:

  class Packages;

  Packages & _packages;

  std::set<std::string> _filerequires;

public:

  bool packagesValid() const;

  const std::list<Package::Ptr> & getPackages();

  //
  // Direct RPM database retrieval via librpm.
  //
public:

  std::list<FileInfo> fileList( const std::string & name_r, const Edition & edition_r ) const;

  bool hasFile( const std::string & file_r, const std::string & name_r = "" ) const;

  std::string whoOwnsFile( const std::string & file_r ) const;

  bool hasProvides( const std::string & tag_r ) const;

  bool hasRequiredBy( const std::string & tag_r ) const;

  bool hasConflicts( const std::string & tag_r ) const;

  bool hasPackage( const std::string & name_r ) const;

  bool hasPackage( const std::string & name_r, const Edition & ed_r ) const;

  void getData( const std::string & name_r,
                RpmHeader::constPtr & result_r ) const;

  void getData( const std::string & name_r, const Edition & ed_r,
                RpmHeader::constPtr & result_r ) const;


  static Package::Ptr makePackageFromHeader( const RpmHeader::constPtr header,
                                             std::set<std::string> * filerequires,
                                             const Pathname & location, Repository repo );

  //
public:
  void importZyppKeyRingTrustedKeys();
  void exportTrustedKeysInZyppKeyRing();
private:
  ExternalProgram *process;

  typedef std::vector<const char*> RpmArgVec;

  void run_rpm( const RpmArgVec& options,
                ExternalProgram::Stderr_Disposition stderr_disp =
                  ExternalProgram::Stderr_To_Stdout);


  bool systemReadLine(std::string &line);

  int systemStatus();

  void systemKill();

  int exit_code;

  Pathname _backuppath;

  bool _packagebackups;

  bool _warndirexists;

  void processConfigFiles(const std::string& line,
                          const std::string& name,
                          const char* typemsg,
                          const char* difffailmsg,
                          const char* diffgenmsg);


public:

  typedef std::set<std::string> FileList;

  enum RpmInstFlag
  {
    RPMINST_NONE       = 0x0000,
    RPMINST_NODOCS     = 0x0001,
    RPMINST_NOSCRIPTS  = 0x0002,
    RPMINST_FORCE      = 0x0004,
    RPMINST_NODEPS     = 0x0008,
    RPMINST_IGNORESIZE = 0x0010,
    RPMINST_JUSTDB     = 0x0020,
    RPMINST_NODIGEST   = 0x0040,
    RPMINST_NOSIGNATURE= 0x0080,
    RPMINST_NOUPGRADE  = 0x0100,
    RPMINST_TEST         = 0x0200
  };

  enum checkPackageResult
  {
    CHK_OK            = 0, 
    CHK_NOTFOUND      = 1, 
    CHK_FAIL          = 2, 
    CHK_NOTTRUSTED    = 3, 
    CHK_NOKEY         = 4, 
    CHK_ERROR         = 5  
  };

  checkPackageResult checkPackage( const Pathname & path_r );

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

  void removePackage(const std::string & name_r, unsigned flags = 0);
  void removePackage(Package::constPtr package, unsigned flags = 0);

  Pathname getBackupPath (void)
  {
    return _backuppath;
  }

  bool backupPackage(const std::string& packageName);

  bool backupPackage(const Pathname& filename);

  void setBackupPath(const Pathname& path);

  void createPackageBackups(bool yes)
  {
    _packagebackups = yes;
  }

  bool queryChangedFiles(FileList & fileList, const std::string& packageName);

public:

  virtual std::ostream & dumpOn( std::ostream & str ) const;

protected:
  void doRemovePackage( const std::string & name_r, unsigned flags, callback::SendReport<RpmRemoveReport> & report );
  void doInstallPackage( const Pathname & filename, unsigned flags, callback::SendReport<RpmInstallReport> & report );
  const std::list<Package::Ptr> & doGetPackages(callback::SendReport<ScanDBReport> & report);
  void doRebuildDatabase(callback::SendReport<RebuildDBReport> & report);


};

} // namespace rpm
} // namespace target
} // namespace zypp

#endif // ZYPP_TARGET_RPM_RPMDB_H

---