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/Source.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 Pathname & pubkey_r );

        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, Source_Ref source );

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

---