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

      _report->progress(progress);
      bool value = true;
      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()
      {}

      virtual ZYPP_DEPRECATED void startPatchDownload( const Pathname & /*filename*/, const ByteCount & /*downloadsize*/ )
      {}

      virtual ZYPP_DEPRECATED bool progressPatchDownload( int /*value*/ )
      { return true; }

      virtual ZYPP_DEPRECATED void problemPatchDownload( const std::string &/*description*/ )
      {}

      virtual ZYPP_DEPRECATED void finishPatchDownload()
      {}


      // 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*/
        ) {}
      };

      // 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*/
        ) {}
      };

      // 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*/
        ) {}
      };

      // progress for converting the database
      struct 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*/
        ) {}
      };

    } // 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 _MsgTypeDef {
      enum Enum { debug, info, warning, error, important, data };
    };
    typedef base::EnumClass<_MsgTypeDef> 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 MessageString & msg_r, const UserData & userData_r = UserData() )
    { return instance()->message( MsgType::debug, msg_r, userData_r ); }

    static bool info( const MessageString & msg_r, const UserData & userData_r = UserData() )
    { return instance()->message( MsgType::info, msg_r, userData_r ); }

    static bool warning( const MessageString & msg_r, const UserData & userData_r = UserData() )
    { return instance()->message( MsgType::warning, msg_r, userData_r ); }

    static bool error( const MessageString & msg_r, const UserData & userData_r = UserData() )
    { return instance()->message( MsgType::error, msg_r, userData_r ); }

    static bool important( const MessageString & msg_r, const UserData & userData_r = UserData() )
    { return instance()->message( MsgType::important, msg_r, userData_r ); }

    static bool data( const MessageString & msg_r, const UserData & userData_r = UserData() )
    { return instance()->message( MsgType::data, msg_r, userData_r ); }
  };


} // namespace zypp

#endif // ZYPP_ZYPPCALLBACKS_H