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 <functional>
 
#include <zypp/Pathname.h>
#include <zypp/ExternalProgram.h>
 
#include <zypp/Package.h>
#include <zypp/KeyRing.h>
 
#include <zypp/target/rpm/RpmFlags.h>
#include <zypp/target/rpm/RpmHeader.h>
#include <zypp/target/rpm/RpmCallbacks.h>
#include <zypp/target/rpm/librpmDb.h>
#include <zypp/ZYppCallbacks.h>
 
namespace zypp
{
namespace target
{
class RpmPostTransCollector;
namespace rpm
{

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

  using Error = class InstTargetError;

  struct db_const_iterator : public librpmDb::db_const_iterator
  {
  private:
    friend class RpmDb;
    db_const_iterator()
    : librpmDb::db_const_iterator { nullptr }
    {}
    db_const_iterator( const Pathname & root_r, const Pathname & dbPath_r )
    : librpmDb::db_const_iterator { root_r, dbPath_r }
    {}
  };

  //
  // INITALISATION
  //
private:

  Pathname _root;

  Pathname _dbPath;
 
public:

  RpmDb();

  ~RpmDb() override;

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

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

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

  db_const_iterator dbConstIterator() const;

  void initDatabase( Pathname root_r = Pathname(), bool doRebuild_r = false );

  void closeDatabase();

  void rebuildDatabase();

  void importPubkey( const PublicKey & pubkey_r );

  void removePubkey( const PublicKey & pubkey_r );

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

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

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

  //
public:
  enum SyncTrustedKeyBits
  {
    SYNC_TO_KEYRING      = 1<<0, 
    SYNC_FROM_KEYRING  = 1<<1, 
    SYNC_BOTH          = SYNC_TO_KEYRING | SYNC_FROM_KEYRING
  };

  void syncTrustedKeys( SyncTrustedKeyBits mode_r = SYNC_BOTH );
  void importZyppKeyRingTrustedKeys();
  void exportTrustedKeysInZyppKeyRing();
 
private:
  ExternalProgram *process;
 
  using RpmArgVec = std::vector<const char *>;

  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;

  std::string error_message;

  Pathname _backuppath;

  bool _packagebackups;

  void processConfigFiles(const std::string& line,
                          const std::string& name,
                          const char* typemsg,
                          const char* difffailmsg,
                          const char* diffgenmsg);
 
 
public:
 
  using FileList = std::set<std::string>;

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

  struct CheckPackageDetail : std::vector<std::pair<CheckPackageResult,std::string>>
  {};

  CheckPackageResult checkPackage( const Pathname & path_r, CheckPackageDetail & detail_r );
  CheckPackageResult checkPackage( const Pathname & path_r );

  CheckPackageResult checkPackageSignature( const Pathname & path_r, CheckPackageDetail & detail_r );

  void installPackage ( const Pathname & filename, RpmInstFlags flags = RPMINST_NONE );
  void installPackage( const Pathname & filename, RpmInstFlags flags, RpmPostTransCollector* postTransCollector_r );

  void removePackage( const std::string & name_r, RpmInstFlags flags = RPMINST_NONE );
  void removePackage( Package::constPtr package, RpmInstFlags flags = RPMINST_NONE );
  void removePackage( const std::string & name_r, RpmInstFlags flags, RpmPostTransCollector* postTransCollector_r );
  void removePackage( const Package::constPtr& package, RpmInstFlags flags, RpmPostTransCollector* postTransCollector_r );

  int runposttrans( const Pathname & filename_r, const std::function<void(const std::string&)>& output_r );

  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:

  std::ostream & dumpOn( std::ostream & str ) const override;
 
protected:
  void doRemovePackage( const std::string & name_r, RpmInstFlags flags, RpmPostTransCollector* postTransCollector_r, callback::SendReport<RpmRemoveReport> & report );
  void doInstallPackage( const Pathname & filename, RpmInstFlags flags, RpmPostTransCollector* postTransCollector_r, callback::SendReport<RpmInstallReport> & report );
  void doRebuildDatabase(callback::SendReport<RebuildDBReport> & report);
};

std::ostream & operator<<( std::ostream & str, RpmDb::CheckPackageResult obj ) ZYPP_API;

std::ostream & operator<<( std::ostream & str, const RpmDb::CheckPackageDetail & obj ) ZYPP_API;
 
} // namespace rpm
} // namespace target
} // namespace zypp
 
#endif // ZYPP_TARGET_RPM_RPMDB_H