ZYppCallbacks.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_ZYPPCALLBACKS_H
#define ZYPP_ZYPPCALLBACKS_H
 
#include <zypp/base/EnumClass.h>
#include <zypp/Callback.h>
#include <zypp/UserData.h>
#include <zypp/Resolvable.h>
#include <zypp/RepoInfo.h>
#include <zypp/Pathname.h>
#include <zypp/Package.h>
#include <zypp/Patch.h>
#include <zypp/Url.h>
#include <zypp/ProgressData.h>
#include <zypp/media/MediaUserAuth.h>
 
namespace zypp
{ 
 
  namespace sat
  {
    class Queue;
    class FileConflicts;
  } // namespace sat
 
  struct ProgressReport : public callback::ReportBase
  {
    virtual void start( const ProgressData &/*task*/ )
    {}
 
    virtual bool progress( const ProgressData &/*task*/ )
    { return true; }
 
//     virtual Action problem(
//         Repo /*source*/
//         , Error /*error*/
//         , const std::string &/*description*/ )
//     { return ABORT; }
 
    virtual void finish( const ProgressData &/*task*/ )
    {}
 
  };
 
  struct ProgressReportAdaptor
  {
 
    ProgressReportAdaptor( const ProgressData::ReceiverFnc &fnc,
                           callback::SendReport<ProgressReport> &report )
      : _fnc(fnc)
      , _report(report)
      , _first(true)
    {
    }
 
    bool operator()( const ProgressData &progress )
    {
      if ( _first )
      {
        _report->start(progress);
        _first = false;
      }
 
      bool value = _report->progress(progress);
      if ( _fnc )
        value &= _fnc(progress);
 
      if ( progress.finalReport() )
      {
        _report->finish(progress);
      }
      return value;
    }
 
    ProgressData::ReceiverFnc _fnc;
    callback::SendReport<ProgressReport> &_report;
    bool _first;
  };
 
 
  namespace repo
  {
    // progress for downloading a resolvable
    struct DownloadResolvableReport : public callback::ReportBase
    {
      enum Action {
        ABORT,  // abort and return error
        RETRY,  // retry
        IGNORE, // ignore this resolvable but continue
      };
 
      enum Error {
        NO_ERROR,
        NOT_FOUND,      // the requested Url was not found
        IO,             // IO error
        INVALID         // the downloaded file is invalid
      };
 
      virtual void infoInCache( Resolvable::constPtr res_r, const Pathname & localfile_r )
      {}
 
      virtual void start(
        Resolvable::constPtr /*resolvable_ptr*/
        , const Url &/*url*/
      ) {}
 
 
      // Dowmload delta rpm:
      // - path below url reported on start()
      // - expected download size (0 if unknown)
      // - download is interruptable
      // - problems are just informal
      virtual void startDeltaDownload( const Pathname & /*filename*/, const ByteCount & /*downloadsize*/ )
      {}
 
      virtual bool progressDeltaDownload( int /*value*/ )
      { return true; }
 
      virtual void problemDeltaDownload( const std::string &/*description*/ )
      {}
 
      virtual void finishDeltaDownload()
      {}
 
      // Apply delta rpm:
      // - local path of downloaded delta
      // - aplpy is not interruptable
      // - problems are just informal
      virtual void startDeltaApply( const Pathname & /*filename*/ )
      {}
 
      virtual void progressDeltaApply( int /*value*/ )
      {}
 
      virtual void problemDeltaApply( const std::string &/*description*/ )
      {}
 
      virtual void finishDeltaApply()
      {}
 
      // return false if the download should be aborted right now
      virtual bool progress(int /*value*/, Resolvable::constPtr /*resolvable_ptr*/)
      { return true; }
 
      virtual Action problem(
        Resolvable::constPtr /*resolvable_ptr*/
        , Error /*error*/
        , const std::string &/*description*/
      ) { return ABORT; }
 
 
      virtual void pkgGpgCheck( const UserData & userData_r = UserData() )
      {}
 
      virtual void finish(Resolvable::constPtr /*resolvable_ptr*/
        , Error /*error*/
        , const std::string &/*reason*/
      ) {}
    };
 
    // progress for probing a source
    struct ProbeRepoReport : public callback::ReportBase
    {
      enum Action {
        ABORT,  // abort and return error
        RETRY   // retry
      };
 
      enum Error {
        NO_ERROR,
        NOT_FOUND,      // the requested Url was not found
        IO,             // IO error
        INVALID,                // th source is invalid
        UNKNOWN
      };
 
      virtual void start(const Url &/*url*/) {}
      virtual void failedProbe( const Url &/*url*/, const std::string &/*type*/ ) {}
      virtual void successProbe( const Url &/*url*/, const std::string &/*type*/ ) {}
      virtual void finish(const Url &/*url*/, Error /*error*/, const std::string &/*reason*/ ) {}
 
      virtual bool progress(const Url &/*url*/, int /*value*/)
      { return true; }
 
      virtual Action problem( const Url &/*url*/, Error /*error*/, const std::string &/*description*/ ) { return ABORT; }
    };
 
    struct RepoCreateReport : public callback::ReportBase
    {
      enum Action {
        ABORT,  // abort and return error
        RETRY,  // retry
        IGNORE  // skip refresh, ignore failed refresh
      };
 
      enum Error {
        NO_ERROR,
        NOT_FOUND,      // the requested Url was not found
        IO,             // IO error
        REJECTED,
        INVALID, // th source is invali
        UNKNOWN
      };
 
      virtual void start( const zypp::Url &/*url*/ ) {}
      virtual bool progress( int /*value*/ )
      { return true; }
 
      virtual Action problem(
          const zypp::Url &/*url*/
          , Error /*error*/
          , const std::string &/*description*/ )
      { return ABORT; }
 
      virtual void finish(
          const zypp::Url &/*url*/
          , Error /*error*/
          , const std::string &/*reason*/ )
      {}
    };
 
    struct RepoReport : public callback::ReportBase
    {
      enum Action {
        ABORT,  // abort and return error
        RETRY,  // retry
        IGNORE  // skip refresh, ignore failed refresh
      };
 
      enum Error {
        NO_ERROR,
        NOT_FOUND,      // the requested Url was not found
        IO,             // IO error
        INVALID         // th source is invalid
      };
 
      virtual void start( const ProgressData &/*task*/, const RepoInfo /*repo*/  ) {}
      virtual bool progress( const ProgressData &/*task*/ )
      { return true; }
 
      virtual Action problem(
          Repository /*source*/
          , Error /*error*/
          , const std::string &/*description*/ )
      { return ABORT; }
 
      virtual void finish(
          Repository /*source*/
          , const std::string &/*task*/
          , Error /*error*/
          , const std::string &/*reason*/ )
      {}
    };
 
 
  } // namespace source
 
  namespace media
  {
    // media change request callback
    struct MediaChangeReport : public callback::ReportBase
    {
      enum Action {
        ABORT,  // abort and return error
        RETRY,  // retry
        IGNORE, // ignore this media in future, not available anymore
        IGNORE_ID,      // ignore wrong medium id
        CHANGE_URL,     // change media URL
        EJECT           // eject the medium
      };
 
      enum Error {
        NO_ERROR,
        NOT_FOUND,  // the medie not found at all
        IO,     // error accessing the media
        INVALID, // media is broken
        WRONG,  // wrong media, need a different one
        IO_SOFT       
      };
 
      virtual Action requestMedia(
        Url & /* url (I/O parameter) */
        , unsigned /*mediumNr*/
        , const std::string & /* label */
        , Error /*error*/
        , const std::string & /*description*/
        , const std::vector<std::string> & /* devices */
        , unsigned int & /* dev_current (I/O param) */
      ) { return ABORT; }
    };
 
    struct ScopedDisableMediaChangeReport
    {
      ScopedDisableMediaChangeReport( bool condition_r = true );
    private:
      shared_ptr<callback::TempConnect<media::MediaChangeReport> > _guard;
    };
 
    // progress for downloading a file
    struct DownloadProgressReport : public callback::ReportBase
    {
        enum Action {
          ABORT,  // abort and return error
          RETRY,        // retry
          IGNORE        // ignore the failure
        };
 
        enum Error {
          NO_ERROR,
          NOT_FOUND,    // the requested Url was not found
          IO,           // IO error
          ACCESS_DENIED, // user authent. failed while accessing restricted file
          ERROR // other error
        };
 
        virtual void start( const Url &/*file*/, Pathname /*localfile*/ ) {}
 
        virtual bool progress(int /*value*/, const Url &/*file*/,
                              double dbps_avg = -1,
                              double dbps_current = -1)
        { return true; }
 
        virtual Action problem(
          const Url &/*file*/
          , Error /*error*/
          , const std::string &/*description*/
        ) { return ABORT; }
 
        virtual void finish(
          const Url &/*file*/
          , Error /*error*/
          , const std::string &/*reason*/
        ) {}
    };
 
    // authentication issues report
    struct AuthenticationReport : public callback::ReportBase
    {
      virtual bool prompt(const Url & /* url */,
        const std::string & /* msg */,
        AuthData & /* auth_data */)
      {
        return false;
      }
    };
 
  } // namespace media
 
  namespace target
  {
    struct PatchMessageReport : public callback::ReportBase
    {
      virtual bool show( Patch::constPtr & /*patch*/ )
      { return true; }
    };
 
    struct PatchScriptReport : public callback::ReportBase
    {
      enum Notify { OUTPUT, PING };
      enum Action {
        ABORT,  // abort commit and return error
        RETRY,  // (re)try to execute this script
        IGNORE  // ignore any failue and continue
      };
 
      virtual void start( const Package::constPtr & /*package*/,
                          const Pathname & /*script path*/ )
      {}
      virtual bool progress( Notify /*OUTPUT or PING*/,
                             const std::string & /*output*/ = std::string() )
      { return true; }
      virtual Action problem( const std::string & /*description*/ )
      { return ABORT; }
      virtual void finish()
      {}
    };
 
    struct FindFileConflictstReport : public callback::ReportBase
    {
      virtual bool start( const ProgressData & progress_r )
      { return true; }
 
      virtual bool progress( const ProgressData & progress_r, const sat::Queue & noFilelist_r )
      { return true; }
 
      virtual bool result( const ProgressData & progress_r, const sat::Queue & noFilelist_r, const sat::FileConflicts & conflicts_r )
      { return true; }
    };
 
 
    namespace rpm
    {
 
      // progress for installing a resolvable
      struct InstallResolvableReport : public callback::ReportBase
      {
        enum Action {
          ABORT,  // abort and return error
          RETRY,        // retry
          IGNORE        // ignore the failure
        };
 
        enum Error {
          NO_ERROR,
          NOT_FOUND,    // the requested Url was not found
          IO,           // IO error
          INVALID               // th resolvable is invalid
        };
 
        // the level of RPM pushing
        enum RpmLevel {
            RPM,
            RPM_NODEPS,
            RPM_NODEPS_FORCE    
        };
 
        virtual void start(
          Resolvable::constPtr /*resolvable*/
        ) {}
 
        virtual bool progress(int /*value*/, Resolvable::constPtr /*resolvable*/)
        { return true; }
 
        virtual Action problem(
          Resolvable::constPtr /*resolvable*/
          , Error /*error*/
          , const std::string &/*description*/
          , RpmLevel /*level*/
        ) { return ABORT; }
 
        virtual void finish(
          Resolvable::constPtr /*resolvable*/
          , Error /*error*/
          , const std::string &/*reason*/
          , RpmLevel /*level*/
        ) {}
 
        static const UserData::ContentType contentRpmout;
      };
 
      // progress for removing a resolvable
      struct RemoveResolvableReport : public callback::ReportBase
      {
        enum Action {
          ABORT,  // abort and return error
          RETRY,        // retry
          IGNORE        // ignore the failure
        };
 
        enum Error {
          NO_ERROR,
          NOT_FOUND,    // the requested Url was not found
          IO,           // IO error
          INVALID               // th resolvable is invalid
        };
 
        virtual void start(
          Resolvable::constPtr /*resolvable*/
        ) {}
 
        virtual bool progress(int /*value*/, Resolvable::constPtr /*resolvable*/)
        { return true; }
 
        virtual Action problem(
          Resolvable::constPtr /*resolvable*/
          , Error /*error*/
          , const std::string &/*description*/
        ) { return ABORT; }
 
        virtual void finish(
          Resolvable::constPtr /*resolvable*/
          , Error /*error*/
          , const std::string &/*reason*/
        ) {}
 
        static const UserData::ContentType contentRpmout;
      };
 
      // progress for rebuilding the database
      struct RebuildDBReport : public callback::ReportBase
      {
        enum Action {
          ABORT,  // abort and return error
          RETRY,        // retry
          IGNORE        // ignore the failure
        };
 
        enum Error {
          NO_ERROR,
          FAILED                // failed to rebuild
        };
 
        virtual void start(Pathname /*path*/) {}
 
        virtual bool progress(int /*value*/, Pathname /*path*/)
        { return true; }
 
        virtual Action problem(
          Pathname /*path*/
         , Error /*error*/
         , const std::string &/*description*/
        ) { return ABORT; }
 
        virtual void finish(
          Pathname /*path*/
          , Error /*error*/
          , const std::string &/*reason*/
        ) {}
      };
 
#if LEGACY(17)
      // progress for converting the database
      struct ZYPP_DEPRECATED ConvertDBReport : public callback::ReportBase
      {
        enum Action {
          ABORT,  // abort and return error
          RETRY,  // retry
          IGNORE  // ignore the failure
        };
 
        enum Error {
          NO_ERROR,
          FAILED // conversion failed
        };
 
        virtual void start( Pathname /*path*/ )
        {}
 
        virtual bool progress( int/*value*/, Pathname/*path*/ )
        { return true; }
 
        virtual Action problem( Pathname/*path*/, Error/*error*/, const std::string &/*description*/ )
        { return ABORT; }
 
        virtual void finish( Pathname/*path*/, Error/*error*/, const std::string &/*reason*/ )
        {}
      };
#endif
    } // namespace rpm
 
  } // namespace target
 
  class PoolQuery;
 
  struct CleanEmptyLocksReport : public callback::ReportBase
  {
    enum Action {
      ABORT,  
      DELETE, 
      IGNORE  
    };
 
    enum Error {
      NO_ERROR, 
      ABORTED 
    };
 
    virtual void start(
    ) {}
 
    virtual bool progress(int /*value*/)
    { return true; }
 
    virtual Action execute(
        const PoolQuery& /*error*/
     ) { return DELETE; }
 
     virtual void finish(
       Error /*error*/
      ) {}
 
  };
 
  struct SavingLocksReport : public callback::ReportBase
  {
    enum Action {
      ABORT,  
      DELETE, 
      IGNORE  
    };
 
    enum Error {
      NO_ERROR, 
      ABORTED  
    };
 
    enum ConflictState{
      SAME_RESULTS, 
      INTERSECT 
    };
 
    virtual void start() {}
 
    virtual bool progress()
    { return true; }
 
    virtual Action conflict(
         const PoolQuery&, 
       ConflictState
     ) { return DELETE; }
 
     virtual void finish(
       Error /*error*/
      ) {}
  };
 
  struct JobReport : public callback::ReportBase
  {
  public:
    struct EMsgTypeDef {
      enum Enum { debug, info, warning, error, important, data };
    };
    typedef base::EnumClass<EMsgTypeDef> MsgType;       
 
    typedef callback::UserData UserData;
 
  public:
    virtual bool message( MsgType type_r, const std::string & msg_r, const UserData & userData_r ) const
    { return true; }
 
 
    static callback::SendReport<JobReport> & instance();        // impl in ZYppImpl.cc
 
    static bool debug( const std::string & msg_r, const UserData & userData_r = UserData() )
    { return instance()->message( MsgType::debug, msg_r, userData_r ); }
 
    static bool info( const std::string & msg_r, const UserData & userData_r = UserData() )
    { return instance()->message( MsgType::info, msg_r, userData_r ); }
 
    static bool warning( const std::string & msg_r, const UserData & userData_r = UserData() )
    { return instance()->message( MsgType::warning, msg_r, userData_r ); }
 
    static bool error( const std::string & msg_r, const UserData & userData_r = UserData() )
    { return instance()->message( MsgType::error, msg_r, userData_r ); }
 
    static bool important( const std::string & msg_r, const UserData & userData_r = UserData() )
    { return instance()->message( MsgType::important, msg_r, userData_r ); }
 
    static bool data( const std::string & msg_r, const UserData & userData_r = UserData() )
    { return instance()->message( MsgType::data, msg_r, userData_r ); }
  };
 
 
} // namespace zypp
 
#endif // ZYPP_ZYPPCALLBACKS_H