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/Url.h"
  20
  21 ///////////////////////////////////////////////////////////////////
  22 namespace zypp
  23 { /////////////////////////////////////////////////////////////////
  24   namespace source
  25   {
  26     // progress for downloading a resolvable
  27     struct DownloadResolvableReport : public callback::ReportBase
  28     {
  29       enum Action {
  30         ABORT,  // abort and return error
  31         RETRY   // retry
  32       };
  33
  34       enum Error {
  35         NO_ERROR,
  36         NOT_FOUND,      // the requested Url was not found
  37         IO,             // IO error
  38         INVALID         // the downloaded file is invalid
  39       };
  40
  41       virtual void start(
  42         Resolvable::Ptr resolvable_ptr
  43         , Url url
  44       ) {}
  45
  46       // return false if the download should be aborted right now
  47       virtual bool progress(int value, Resolvable::Ptr resolvable_ptr)
  48       { return true; }
  49
  50       virtual Action problem(
  51         Resolvable::Ptr resolvable_ptr
  52         , Error error
  53         , std::string description
  54       ) { return ABORT; }
  55
  56       virtual void finish(Resolvable::Ptr resolvable_ptr
  57         , Error error
  58         , std::string reason
  59       ) {}
  60     };
  61
  62
  63     // progress for downloading a specific file
  64     struct DownloadFileReport : public callback::ReportBase
  65     {
  66       enum Action {
  67         ABORT,  // abort and return error
  68         RETRY   // retry
  69       };
  70
  71       enum Error {
  72         NO_ERROR,
  73         NOT_FOUND,      // the requested Url was not found
  74         IO,             // IO error
  75         INVALID         // the downloaded file is invalid
  76       };
  77       virtual void start(
  78         Source_Ref source
  79         , Url url
  80       ) {}
  81
  82       virtual bool progress(int value, Url url)
  83       { return true; }
  84
  85       virtual Action problem(
  86         Url url
  87         , Error error
  88         , std::string description
  89       ) { return ABORT; }
  90
  91       virtual void finish(
  92         Url url
  93         , Error error
  94         , std::string reason
  95       ) {}
  96     };
  97
  98     // progress for refreshing a source data
  99     struct RefreshSourceReport : public callback::ReportBase
 100     {
 101       enum Action {
 102         ABORT,  // abort and return error
 103         RETRY   // retry
 104       };
 105
 106       enum Error {
 107         NO_ERROR,
 108         NOT_FOUND,      // the requested Url was not found
 109         IO,             // IO error
 110         INVALID         // th source is invalid
 111       };
 112       virtual void start(
 113         Source_Ref source
 114         , Url url
 115       ) {}
 116
 117       virtual bool progress(int value, Source_Ref source)
 118       { return true; }
 119
 120       virtual Action problem(
 121         Source_Ref source
 122         , Error error
 123         , std::string description
 124       ) { return ABORT; }
 125
 126       virtual void finish(
 127         Source_Ref source
 128         , Error error
 129         , std::string reason
 130       ) {}
 131     };
 132
 133     // progress for creating a source (download and parsing)
 134     struct CreateSourceReport : public callback::ReportBase
 135     {
 136       enum Action {
 137         ABORT,  // abort and return error
 138         RETRY   // retry
 139       };
 140
 141       enum Error {
 142         NO_ERROR,
 143         NOT_FOUND,      // the requested Url was not found
 144         IO,             // IO error
 145         INVALID         // th source is invalid
 146       };
 147       virtual void start(
 148         Source_Ref source
 149         , Url url
 150       ) {}
 151
 152       virtual bool progress(int value, Url url)
 153       { return true; }
 154
 155       virtual Action problem(
 156         Url url
 157         , Error error
 158         , std::string description
 159       ) { return ABORT; }
 160
 161       virtual void finish(
 162         Url url
 163         , Error error
 164         , std::string reason
 165       ) {}
 166     };
 167
 168     /////////////////////////////////////////////////////////////////
 169   } // namespace source
 170   ///////////////////////////////////////////////////////////////////
 171
 172   ///////////////////////////////////////////////////////////////////
 173   namespace media
 174   {
 175     // media change request callback
 176     struct MediaChangeReport : public callback::ReportBase
 177     {
 178       enum Action {
 179         ABORT,  // abort and return error
 180         RETRY,  // retry
 181         IGNORE, // ignore this media in future, not available anymore
 182       };
 183
 184       enum Error {
 185         NO_ERROR,
 186         NOT_FOUND,  // the medie not found at all
 187         IO,     // error accessing the media
 188         INVALID, // media is broken
 189         WRONG   // wrong media, need a different one
 190       };
 191
 192       virtual Action requestMedia(
 193         const Source_Ref source
 194         , unsigned mediumNr
 195         , Error error
 196         , std::string description
 197       ) { return ABORT; }
 198     };
 199
 200     /////////////////////////////////////////////////////////////////
 201   } // namespace media
 202   ///////////////////////////////////////////////////////////////////
 203
 204   ///////////////////////////////////////////////////////////////////
 205   namespace target
 206   {
 207
 208     ///////////////////////////////////////////////////////////////////
 209     namespace rpm
 210     {
 211
 212       // progress for installing a resolvable
 213       struct InstallResolvableReport : public callback::ReportBase
 214       {
 215         enum Action {
 216           ABORT,  // abort and return error
 217           RETRY,        // retry
 218           IGNORE        // ignore the failure
 219         };
 220
 221         enum Error {
 222           NO_ERROR,
 223           NOT_FOUND,    // the requested Url was not found
 224           IO,           // IO error
 225           INVALID               // th resolvable is invalid
 226         };
 227
 228         virtual void start(
 229           Resolvable::constPtr resolvable
 230         ) {}
 231
 232         virtual bool progress(int value, Resolvable::constPtr resolvable)
 233         { return true; }
 234
 235         virtual Action problem(
 236           Resolvable::constPtr resolvable
 237           , Error error
 238          , std::string description
 239         ) { return ABORT; }
 240
 241         virtual void finish(
 242           Resolvable::constPtr resolvable
 243           , Error error
 244           , std::string reason
 245         ) {}
 246       };
 247
 248       // progress for removing a resolvable
 249       struct RemoveResolvableReport : public callback::ReportBase
 250       {
 251         enum Action {
 252           ABORT,  // abort and return error
 253           RETRY,        // retry
 254           IGNORE        // ignore the failure
 255         };
 256
 257         enum Error {
 258           NO_ERROR,
 259           NOT_FOUND,    // the requested Url was not found
 260           IO,           // IO error
 261           INVALID               // th resolvable is invalid
 262         };
 263
 264         virtual void start(
 265           Resolvable::Ptr resolvable
 266         ) {}
 267
 268         virtual bool progress(int value, Resolvable::Ptr resolvable)
 269         { return true; }
 270
 271         virtual Action problem(
 272           Resolvable::Ptr resolvable
 273           , Error error
 274          , std::string description
 275         ) { return ABORT; }
 276
 277         virtual void finish(
 278           Resolvable::Ptr resolvable
 279           , Error error
 280           , std::string reason
 281         ) {}
 282       };
 283
 284       // progress for rebuilding the database
 285       struct RebuildDBReport : public callback::ReportBase
 286       {
 287         enum Action {
 288           ABORT,  // abort and return error
 289           RETRY,        // retry
 290           IGNORE        // ignore the failure
 291         };
 292
 293         enum Error {
 294           NO_ERROR,
 295           NOT_FOUND,    // the requested Url was not found
 296           IO,           // IO error
 297           INVALID               // th resolvable is invalid
 298         };
 299
 300         virtual void start(
 301           Pathname path
 302         ) {}
 303
 304         virtual bool progress(int value, Pathname path)
 305         { return true; }
 306
 307         virtual Action problem(
 308           Pathname path
 309           , Error error
 310          , std::string description
 311         ) { return ABORT; }
 312
 313         virtual void finish(
 314           Pathname path
 315           , Error error
 316           , std::string reason
 317         ) {}
 318       };
 319
 320       // progress for converting the database
 321       struct ConvertDBReport : public callback::ReportBase
 322       {
 323         enum Action {
 324           ABORT,  // abort and return error
 325           RETRY,        // retry
 326           IGNORE        // ignore the failure
 327         };
 328
 329         enum Error {
 330           NO_ERROR,
 331           NOT_FOUND,    // the requested Url was not found
 332           IO,           // IO error
 333           INVALID               // th resolvable is invalid
 334         };
 335
 336         virtual void start(
 337           Pathname path
 338         ) {}
 339
 340         virtual bool progress(int value, Pathname path)
 341         { return true; }
 342
 343         virtual Action problem(
 344           Pathname path
 345           , Error error
 346          , std::string description
 347         ) { return ABORT; }
 348
 349         virtual void finish(
 350           Pathname path
 351           , Error error
 352           , std::string reason
 353         ) {}
 354       };
 355
 356       /////////////////////////////////////////////////////////////////
 357     } // namespace rpm
 358     ///////////////////////////////////////////////////////////////////
 359
 360     /////////////////////////////////////////////////////////////////
 361   } // namespace target
 362   ///////////////////////////////////////////////////////////////////
 363
 364   /////////////////////////////////////////////////////////////////
 365 } // namespace zypp
 366 ///////////////////////////////////////////////////////////////////
 367
 368 #endif // ZYPP_ZYPPCALLBACKS_H