zypp/ZYppCallbacks.h

   1 /*---------------------------------------------------------------------\
   2 |                          ____ _   __ __ ___                          |
   3 |                         |__  / \ / / . \ . \                         |
   4 |                           / / \ V /|  _/  _/                         |
   5 |                          / /__ | | | | | |                           |
   6 |                         /_____||_| |_| |_|                           |
   7 |                                                                      |
   8 \---------------------------------------------------------------------*/
   9 /** \file zypp/ZYppCallbacks.h
  10  *
  11 */
  12 #ifndef ZYPP_ZYPPCALLBACKS_H
  13 #define ZYPP_ZYPPCALLBACKS_H
  14
  15 #include "zypp/Callback.h"
  16 #include "zypp/Resolvable.h"
  17 #include "zypp/Source.h"
  18 #include "zypp/Pathname.h"
  19 #include "zypp/Message.h"
  20 #include "zypp/Url.h"
  21 #include "zypp/media/MediaUserAuth.h"
  22
  23 ///////////////////////////////////////////////////////////////////
  24 namespace zypp
  25 { /////////////////////////////////////////////////////////////////
  26   namespace source
  27   {
  28     // progress for downloading a resolvable
  29     struct DownloadResolvableReport : public callback::ReportBase
  30     {
  31       enum Action {
  32         ABORT,  // abort and return error
  33         RETRY,  // retry
  34         IGNORE, // ignore this resolvable but continue
  35       };
  36
  37       enum Error {
  38         NO_ERROR,
  39         NOT_FOUND,      // the requested Url was not found
  40         IO,             // IO error
  41         INVALID         // the downloaded file is invalid
  42       };
  43
  44       virtual void start(
  45         Resolvable::constPtr /*resolvable_ptr*/
  46         , const Url &/*url*/
  47       ) {}
  48
  49
  50       // Dowmload delta rpm:
  51       // - path below url reported on start()
  52       // - expected download size (0 if unknown)
  53       // - download is interruptable
  54       // - problems are just informal
  55       virtual void startDeltaDownload( const Pathname & /*filename*/, const ByteCount & /*downloadsize*/ )
  56       {}
  57
  58       virtual bool progressDeltaDownload( int /*value*/ )
  59       { return true; }
  60
  61       virtual void problemDeltaDownload( const std::string &/*description*/ )
  62       {}
  63
  64       virtual void finishDeltaDownload()
  65       {}
  66
  67       // Apply delta rpm:
  68       // - local path of downloaded delta
  69       // - aplpy is not interruptable
  70       // - problems are just informal
  71       virtual void startDeltaApply( const Pathname & /*filename*/ )
  72       {}
  73
  74       virtual void progressDeltaApply( int /*value*/ )
  75       {}
  76
  77       virtual void problemDeltaApply( const std::string &/*description*/ )
  78       {}
  79
  80       virtual void finishDeltaApply()
  81       {}
  82
  83       // Dowmload patch rpm:
  84       // - path below url reported on start()
  85       // - expected download size (0 if unknown)
  86       // - download is interruptable
  87       virtual void startPatchDownload( const Pathname & /*filename*/, const ByteCount & /*downloadsize*/ )
  88       {}
  89
  90       virtual bool progressPatchDownload( int /*value*/ )
  91       { return true; }
  92
  93       virtual void problemPatchDownload( const std::string &/*description*/ )
  94       {}
  95
  96       virtual void finishPatchDownload()
  97       {}
  98
  99
 100       // return false if the download should be aborted right now
 101       virtual bool progress(int /*value*/, Resolvable::constPtr /*resolvable_ptr*/)
 102       { return true; }
 103
 104       virtual Action problem(
 105         Resolvable::constPtr /*resolvable_ptr*/
 106         , Error /*error*/
 107         , const std::string &/*description*/
 108       ) { return ABORT; }
 109
 110       virtual void finish(Resolvable::constPtr /*resolvable_ptr*/
 111         , Error /*error*/
 112         , const std::string &/*reason*/
 113       ) {}
 114     };
 115
 116     // progress for probing a source
 117     struct ProbeSourceReport : public callback::ReportBase
 118     {
 119       enum Action {
 120         ABORT,  // abort and return error
 121         RETRY   // retry
 122       };
 123
 124       enum Error {
 125         NO_ERROR,
 126         NOT_FOUND,      // the requested Url was not found
 127         IO,             // IO error
 128         INVALID,                // th source is invalid
 129         UNKNOWN
 130       };
 131
 132       virtual void start(const Url &/*url*/) {}
 133       virtual void failedProbe( const Url &/*url*/, const std::string &/*type*/ ) {}
 134       virtual void successProbe( const Url &/*url*/, const std::string &/*type*/ ) {}
 135       virtual void finish(const Url &/*url*/, Error /*error*/, const std::string &/*reason*/ ) {}
 136
 137       virtual bool progress(const Url &/*url*/, int /*value*/)
 138       { return true; }
 139
 140       virtual Action problem( const Url &/*url*/, Error /*error*/, const std::string &/*description*/ ) { return ABORT; }
 141     };
 142
 143     struct SourceCreateReport : public callback::ReportBase
 144     {
 145       enum Action {
 146         ABORT,  // abort and return error
 147         RETRY,  // retry
 148         IGNORE  // skip refresh, ignore failed refresh
 149       };
 150
 151       enum Error {
 152         NO_ERROR,
 153         NOT_FOUND,      // the requested Url was not found
 154         IO,             // IO error
 155         REJECTED,
 156         INVALID, // th source is invali
 157         UNKNOWN
 158       };
 159
 160       virtual void start( const zypp::Url &/*url*/ ) {}
 161       virtual bool progress( int /*value*/ )
 162       { return true; }
 163
 164       virtual Action problem(
 165           const zypp::Url &/*url*/
 166           , Error /*error*/
 167           , const std::string &/*description*/ )
 168       { return ABORT; }
 169
 170       virtual void finish(
 171           const zypp::Url &/*url*/
 172           , Error /*error*/
 173           , const std::string &/*reason*/ )
 174       {}
 175     };
 176
 177     struct SourceReport : public callback::ReportBase
 178     {
 179       enum Action {
 180         ABORT,  // abort and return error
 181         RETRY,  // retry
 182         IGNORE  // skip refresh, ignore failed refresh
 183       };
 184
 185       enum Error {
 186         NO_ERROR,
 187         NOT_FOUND,      // the requested Url was not found
 188         IO,             // IO error
 189         INVALID         // th source is invalid
 190       };
 191
 192       virtual void start( Source_Ref /*source*/, const std::string &/*task*/ ) {}
 193       virtual bool progress( int /*value*/ )
 194       { return true; }
 195
 196       virtual Action problem(
 197           Source_Ref /*source*/
 198           , Error /*error*/
 199           , const std::string &/*description*/ )
 200       { return ABORT; }
 201
 202       virtual void finish(
 203           Source_Ref /*source*/
 204           , const std::string &/*task*/
 205           , Error /*error*/
 206           , const std::string &/*reason*/ )
 207       {}
 208     };
 209
 210
 211     /////////////////////////////////////////////////////////////////
 212   } // namespace source
 213   ///////////////////////////////////////////////////////////////////
 214
 215   ///////////////////////////////////////////////////////////////////
 216   namespace media
 217   {
 218     // media change request callback
 219     struct MediaChangeReport : public callback::ReportBase
 220     {
 221       enum Action {
 222         ABORT,  // abort and return error
 223         RETRY,  // retry
 224         IGNORE, // ignore this media in future, not available anymore
 225         IGNORE_ID,      // ignore wrong medium id
 226         CHANGE_URL,     // change media URL
 227         EJECT           // eject the medium
 228       };
 229
 230       enum Error {
 231         NO_ERROR,
 232         NOT_FOUND,  // the medie not found at all
 233         IO,     // error accessing the media
 234         INVALID, // media is broken
 235         WRONG   // wrong media, need a different one
 236       };
 237
 238       virtual Action requestMedia(
 239         Source_Ref /*source*/
 240         , unsigned /*mediumNr*/
 241         , Error /*error*/
 242         , const std::string &/*description*/
 243       ) { return ABORT; }
 244     };
 245
 246     // progress for downloading a file
 247     struct DownloadProgressReport : public callback::ReportBase
 248     {
 249         enum Action {
 250           ABORT,  // abort and return error
 251           RETRY,        // retry
 252           IGNORE        // ignore the failure
 253         };
 254
 255         enum Error {
 256           NO_ERROR,
 257           NOT_FOUND,    // the requested Url was not found
 258           IO,           // IO error
 259           ACCESS_DENIED // user authent. failed while accessing restricted file
 260         };
 261
 262         virtual void start( const Url &/*file*/, Pathname /*localfile*/ ) {}
 263
 264         virtual bool progress(int /*value*/, const Url &/*file*/)
 265         { return true; }
 266
 267         virtual Action problem(
 268           const Url &/*file*/
 269           , Error /*error*/
 270           , const std::string &/*description*/
 271         ) { return ABORT; }
 272
 273         virtual void finish(
 274           const Url &/*file*/
 275           , Error /*error*/
 276           , const std::string &/*reason*/
 277         ) {}
 278     };
 279
 280     // authentication issues report
 281     struct AuthenticationReport : public callback::ReportBase
 282     {
 283       /**
 284        * Prompt for authentication data.
 285        *
 286        * \param url       URL which required the authentication
 287        * \param msg       prompt text
 288        * \param auth_data input/output object for handling authentication
 289        *        data. As an input parameter auth_data can be prefilled with
 290        *        username (from previous try) or auth_type (available
 291        *        authentication methods aquired from server (only CurlAuthData)).
 292        *        As an output parameter it serves for sending username, pasword
 293        *        or other special data (derived AuthData objects).
 294        * \return true if user chooses to continue with authentication,
 295        *         false otherwise
 296        */
 297       virtual bool prompt(const Url & /* url */,
 298         const std::string & /* msg */,
 299         AuthData & /* auth_data */)
 300       {
 301         return false;
 302       }
 303     };
 304
 305     /////////////////////////////////////////////////////////////////
 306   } // namespace media
 307   ///////////////////////////////////////////////////////////////////
 308
 309   ///////////////////////////////////////////////////////////////////
 310   namespace target
 311   {
 312
 313     // resolvable Message
 314     struct MessageResolvableReport : public callback::ReportBase
 315     {
 316         virtual void show(
 317           Message::constPtr /*message*/
 318         ) {}
 319     };
 320
 321     // resolvable Script
 322     struct ScriptResolvableReport : public callback::ReportBase
 323     {
 324       enum Task   { DO, UNDO };
 325       enum Notify { OUTPUT, PING };
 326
 327       /** Whether executing do_script on install or undo_script on delete. */
 328       virtual void start( const Resolvable::constPtr & /*script_r*/,
 329                           const Pathname & /*path_r*/,
 330                           Task )
 331       {}
 332       /** Progress provides the script output. If the script is quiet,
 333        * from time to time still-alive pings are sent to the ui. Returning \c FALSE
 334        * aborts script execution.
 335       */
 336       virtual bool progress( Notify , const std::string & = std::string() )
 337       { return true; }
 338       /** Report error. */
 339       virtual void problem( const std::string & /*description*/ )
 340       {}
 341       /** Report success. */
 342       virtual void finish()
 343       {}
 344     };
 345
 346     ///////////////////////////////////////////////////////////////////
 347     namespace rpm
 348     {
 349
 350       // progress for installing a resolvable
 351       struct InstallResolvableReport : public callback::ReportBase
 352       {
 353         enum Action {
 354           ABORT,  // abort and return error
 355           RETRY,        // retry
 356           IGNORE        // ignore the failure
 357         };
 358
 359         enum Error {
 360           NO_ERROR,
 361           NOT_FOUND,    // the requested Url was not found
 362           IO,           // IO error
 363           INVALID               // th resolvable is invalid
 364         };
 365
 366         // the level of RPM pushing
 367         enum RpmLevel {
 368             RPM,
 369             RPM_NODEPS,
 370             RPM_NODEPS_FORCE
 371         };
 372
 373         virtual void start(
 374           Resolvable::constPtr /*resolvable*/
 375         ) {}
 376
 377         virtual bool progress(int /*value*/, Resolvable::constPtr /*resolvable*/)
 378         { return true; }
 379
 380         virtual Action problem(
 381           Resolvable::constPtr /*resolvable*/
 382           , Error /*error*/
 383           , const std::string &/*description*/
 384           , RpmLevel /*level*/
 385         ) { return ABORT; }
 386
 387         virtual void finish(
 388           Resolvable::constPtr /*resolvable*/
 389           , Error /*error*/
 390           , const std::string &/*reason*/
 391           , RpmLevel /*level*/
 392         ) {}
 393       };
 394
 395       // progress for removing a resolvable
 396       struct RemoveResolvableReport : public callback::ReportBase
 397       {
 398         enum Action {
 399           ABORT,  // abort and return error
 400           RETRY,        // retry
 401           IGNORE        // ignore the failure
 402         };
 403
 404         enum Error {
 405           NO_ERROR,
 406           NOT_FOUND,    // the requested Url was not found
 407           IO,           // IO error
 408           INVALID               // th resolvable is invalid
 409         };
 410
 411         virtual void start(
 412           Resolvable::constPtr /*resolvable*/
 413         ) {}
 414
 415         virtual bool progress(int /*value*/, Resolvable::constPtr /*resolvable*/)
 416         { return true; }
 417
 418         virtual Action problem(
 419           Resolvable::constPtr /*resolvable*/
 420           , Error /*error*/
 421           , const std::string &/*description*/
 422         ) { return ABORT; }
 423
 424         virtual void finish(
 425           Resolvable::constPtr /*resolvable*/
 426           , Error /*error*/
 427           , const std::string &/*reason*/
 428         ) {}
 429       };
 430
 431       // progress for rebuilding the database
 432       struct RebuildDBReport : public callback::ReportBase
 433       {
 434         enum Action {
 435           ABORT,  // abort and return error
 436           RETRY,        // retry
 437           IGNORE        // ignore the failure
 438         };
 439
 440         enum Error {
 441           NO_ERROR,
 442           FAILED                // failed to rebuild
 443         };
 444
 445         virtual void start(Pathname /*path*/) {}
 446
 447         virtual bool progress(int /*value*/, Pathname /*path*/)
 448         { return true; }
 449
 450         virtual Action problem(
 451           Pathname /*path*/
 452          , Error /*error*/
 453          , const std::string &/*description*/
 454         ) { return ABORT; }
 455
 456         virtual void finish(
 457           Pathname /*path*/
 458           , Error /*error*/
 459           , const std::string &/*reason*/
 460         ) {}
 461       };
 462
 463       // progress for converting the database
 464       struct ConvertDBReport : public callback::ReportBase
 465       {
 466         enum Action {
 467           ABORT,  // abort and return error
 468           RETRY,        // retry
 469           IGNORE        // ignore the failure
 470         };
 471
 472         enum Error {
 473           NO_ERROR,
 474           FAILED                // conversion failed
 475         };
 476
 477         virtual void start(
 478           Pathname /*path*/
 479         ) {}
 480
 481         virtual bool progress(int /*value*/, Pathname /*path*/)
 482         { return true; }
 483
 484         virtual Action problem(
 485           Pathname /*path*/
 486           , Error /*error*/
 487          , const std::string &/*description*/
 488         ) { return ABORT; }
 489
 490         virtual void finish(
 491           Pathname /*path*/
 492           , Error /*error*/
 493           , const std::string &/*reason*/
 494         ) {}
 495       };
 496
 497        // progress for scanning the database
 498       struct ScanDBReport : public callback::ReportBase
 499       {
 500         enum Action {
 501           ABORT,  // abort and return error
 502           RETRY,        // retry
 503           IGNORE        // ignore the failure
 504         };
 505
 506         enum Error {
 507           NO_ERROR,
 508           FAILED                // conversion failed
 509         };
 510
 511         virtual void start(
 512         ) {}
 513
 514         virtual bool progress(int /*value*/)
 515         { return true; }
 516
 517         virtual Action problem(
 518           Error /*error*/
 519          , const std::string &/*description*/
 520         ) { return ABORT; }
 521
 522         virtual void finish(
 523           Error /*error*/
 524           , const std::string &/*reason*/
 525         ) {}
 526       };
 527
 528       /////////////////////////////////////////////////////////////////
 529     } // namespace rpm
 530     ///////////////////////////////////////////////////////////////////
 531
 532     /////////////////////////////////////////////////////////////////
 533   } // namespace target
 534   ///////////////////////////////////////////////////////////////////
 535
 536   /////////////////////////////////////////////////////////////////
 537 } // namespace zypp
 538 ///////////////////////////////////////////////////////////////////
 539
 540 #endif // ZYPP_ZYPPCALLBACKS_H