ZYppCallbacks.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_ZYPPCALLBACKS_H
#define ZYPP_ZYPPCALLBACKS_H
 
#include <zypp-core/base/EnumClass.h>
#include <zypp/Callback.h>
#include <zypp-core/UserData.h>
#include <zypp/Resolvable.h>
#include <zypp/RepoInfo.h>
#include <zypp-core/Pathname.h>
#include <zypp/Package.h>
#include <zypp/Patch.h>
#include <zypp-core/Url.h>
#include <zypp-core/ui/ProgressData>
#include <zypp-media/auth/AuthData>
#include <zypp-curl/auth/CurlAuthData>  // bsc#1194597: CurlAuthData must be exposed for zypper

namespace zypp
{ 

  namespace sat
  {
    class Queue;
    class FileConflicts;
  } // namespace sat
 
  struct ZYPP_API 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( callback::SendReport<ProgressReport> &report )
      : _report(report)
      , _first(true)
    {}
 
    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 ZYPP_API 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 ZYPP_API ZYPP_DEPRECATED 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 ZYPP_API ZYPP_DEPRECATED 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 ZYPP_API ZYPP_DEPRECATED 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 ZYPP_API 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 ZYPP_API ScopedDisableMediaChangeReport
    {
      ScopedDisableMediaChangeReport( bool condition_r = true );
    private:
      shared_ptr<callback::TempConnect<media::MediaChangeReport> > _guard;
    };
 
    // progress for downloading a file
    struct ZYPP_API 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*/
        ) {}
    };
 
    // progress for concurrently preloading a entire commit
    struct ZYPP_API CommitPreloadReport : public callback::ReportBase
    {
        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 UserData &userData = UserData() ) {}

        virtual bool progress( int value, const UserData &userData = UserData() )
        { return true; }

 
        virtual void fileStart(
          const Pathname &localfile,
          const UserData &userData = UserData()
        ) {}

        virtual void fileDone(
          const Pathname &localfile,
          Error error,
          const UserData &userData = UserData()
        ) {}
 
        enum Result {
          SUCCESS, //< everything was fetched as expected
          MISS     //< some files are missing
        };

        virtual void finish( Result res, const UserData &userData = UserData() ) {}
    };
 
    // authentication issues report
    struct ZYPP_API AuthenticationReport : public callback::ReportBase
    {
      virtual bool prompt(const Url & /* url */,
        const std::string & /* msg */,
        AuthData & /* auth_data */)
      {
        return false;
      }
    };

  } // namespace media

  namespace target
  {
    struct ZYPP_API PatchMessageReport : public callback::ReportBase
    {
      virtual bool show( Patch::constPtr & /*patch*/ )
      { return true; }
    };

    struct ZYPP_API 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 ZYPP_API 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; }
    };
 

    struct ZYPP_API CommitActiveReport : public callback::ReportBase
    {
      virtual bool start( const UserData & = UserData() /*userdata*/ ) { return true; }

      virtual void end  ( const UserData & = UserData() /*userdata*/ ) { }
 
      // added for future use to avoid breaking compatibility
      virtual void step ( const UserData & = UserData() /*userdata*/ ) { }
    };

    namespace rpm
    {
 
      // progress for installing a resolvable
      struct ZYPP_API 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 ZYPP_API;
      };
 
      // progress for removing a resolvable
      struct ZYPP_API 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 ZYPP_API;
      };
 
      // progress for rebuilding the database
      struct ZYPP_API 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

      struct ZYPP_API SingleTransReport : public callback::ReportBase
      {
        static const UserData::ContentType contentLogline ZYPP_API;
        enum class loglevel { dbg, msg, war, err, crt };
        static const char *const loglevelPrefix( loglevel level_r )
        {
          switch ( level_r ) {
            case loglevel::crt:  return "fatal error: ";
            case loglevel::err:  return "error: ";
            case loglevel::war:  return "warning: ";
            case loglevel::msg:  return "";
            case loglevel::dbg:  return "D: ";
          }
          return "";
        }
      };
 
      // Generic transaction reports, this is used for verifying and preparing tasks, the name param
      // for the start function defines which report we are looking at
      struct ZYPP_API TransactionReportSA : public callback::ReportBase
      {
        enum Error {
          NO_ERROR, // everything went perfectly fine
          FINISHED_WITH_ERRORS, // the transaction was finished, but some errors happened
          FAILED // the transaction failed completely
        };
 
        virtual void start(
          const std::string &/*name*/,
          const UserData & = UserData() /*userdata*/
          ) {}
 
        virtual void progress(
          int /*value*/,
          const UserData & = UserData() /*userdata*/
          ) { }
 
        virtual void finish(
          Error /*error*/,
          const UserData & = UserData() /*userdata*/
          ) {}

        static const UserData::ContentType contentRpmout ZYPP_API;
      };
 
 
      // progress for installing a resolvable in single transaction mode
      struct ZYPP_API InstallResolvableReportSA : public callback::ReportBase
      {
        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*/,
          const UserData & = UserData() /*userdata*/
          ) {}
 
        virtual void progress(
          int /*value*/,
          Resolvable::constPtr /*resolvable*/,
          const UserData & = UserData() /*userdata*/
          ) { return; }
 
        virtual void finish(
          Resolvable::constPtr /*resolvable*/
          , Error /*error*/,
          const UserData & = UserData() /*userdata*/
          ) {}

        static const UserData::ContentType contentRpmout ZYPP_API;
      };
 
      // progress for removing a resolvable in single transaction mode
      struct ZYPP_API RemoveResolvableReportSA : public callback::ReportBase
      {
        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*/,
          const UserData & = UserData() /*userdata*/
          ) {}
 
        virtual void progress(
          int /*value*/,
          Resolvable::constPtr /*resolvable*/,
          const UserData & = UserData() /*userdata*/
          ) { return; }
 
        virtual void finish(
          Resolvable::constPtr /*resolvable*/
          , Error /*error*/
          , const UserData & = UserData() /*userdata*/
          ) {}

        static const UserData::ContentType contentRpmout ZYPP_API;
      };
 
      // progress for cleaning up the old version of a package after it was upgraded to a new version
      struct ZYPP_API CleanupPackageReportSA : public callback::ReportBase
      {
        enum Error {
          NO_ERROR
        };
 
        virtual void start(
          const std::string & /*nvra*/,
          const UserData & = UserData() /*userdata*/
          ) {}
 
        virtual void progress(
          int /*value*/,
          const UserData & = UserData() /*userdata*/
          ) { return; }
 
        virtual void finish(
          Error /*error*/,
          const UserData & = UserData() /*userdata*/
          ) {}

        static const UserData::ContentType contentRpmout ZYPP_API;
      };
 
 
      // progress for script thats executed during a commit transaction
      // the resolvable can be null, for things like posttrans scripts
      struct ZYPP_API CommitScriptReportSA : public callback::ReportBase
      {
        enum Error {
          NO_ERROR,
          WARN,
          CRITICAL // the script failure prevented solvable installation
        };
 
        virtual void start(
          const std::string &  /*scriptType*/,
          const std::string &  /*packageName ( can be empty )*/,
          Resolvable::constPtr /*resolvable  ( can be null )*/,
          const UserData & = UserData() /*userdata*/
          ) {}
 
        virtual void progress(
          int /*value*/,
          Resolvable::constPtr /*resolvable*/,
          const UserData & = UserData() /*userdata*/
          ) { return; }
 
        virtual void finish(
          Resolvable::constPtr /*resolvable*/
          , Error /*error*/,
          const UserData & = UserData() /*userdata*/
          ) {}

        static const UserData::ContentType contentRpmout ZYPP_API;
      };

    } // namespace rpm

  } // namespace target
 
  class PoolQuery;


 
  struct ZYPP_API 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 ZYPP_API 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 ZYPP_API JobReport : public callback::ReportBase
  {
  public:
    struct EMsgTypeDef {
      enum Enum { debug, info, warning, error, important, data };
    };
    typedef base::EnumClass<EMsgTypeDef> MsgType;       

    typedef callback::UserData UserData;
 
    static const ContentType repoRefreshMirrorlist;
 
  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 ); }

  };

  struct ZYPP_API UserDataJobReport : public JobReport::UserData
  {
    using JobReport::UserData::UserData;
 
    bool debug( const std::string & msg_r )     { return JobReport::debug( msg_r, *this ); }
    bool info( const std::string & msg_r )      { return JobReport::info( msg_r, *this ); }
    bool warning( const std::string & msg_r )   { return JobReport::warning( msg_r, *this ); }
    bool error( const std::string & msg_r )     { return JobReport::error( msg_r, *this ); }
    bool important( const std::string & msg_r ) { return JobReport::important( msg_r, *this ); }
    bool data( const std::string & msg_r )      { return JobReport::data( msg_r, *this ); }
  };

} // namespace zypp
 
#endif // ZYPP_ZYPPCALLBACKS_H