← Back to branch summary

~thopiekar/zypper/libzypp-manual-import

« back to all changes in this revision

Viewing changes to zypp/ZYppCallbacks.h

  • Committer: Thomas-Karl Pietrowski
  • Date: 2014-01-29 22:44:28 UTC
  • Revision ID: thopiekar@googlemail.com-20140129224428-gpcqnsdakby362n8
first import

Show diffs side-by-side

added added

removed removed

Lines of Context:
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/RepoInfo.h"
 
18
#include "zypp/Pathname.h"
 
19
#include "zypp/Package.h"
 
20
#include "zypp/Patch.h"
 
21
#include "zypp/Url.h"
 
22
#include "zypp/ProgressData.h"
 
23
#include "zypp/media/MediaUserAuth.h"
 
24
 
 
25
///////////////////////////////////////////////////////////////////
 
26
namespace zypp
 
27
{ /////////////////////////////////////////////////////////////////
 
28
 
 
29
  ///////////////////////////////////////////////////////////////////
 
30
  namespace sat
 
31
  {
 
32
    class Queue;
 
33
    class FileConflicts;
 
34
  } // namespace sat
 
35
  ///////////////////////////////////////////////////////////////////
 
36
 
 
37
  struct ProgressReport : public callback::ReportBase
 
38
  {
 
39
    virtual void start( const ProgressData &/*task*/ )
 
40
    {}
 
41
 
 
42
    virtual bool progress( const ProgressData &/*task*/ )
 
43
    { return true; }
 
44
 
 
45
//     virtual Action problem(
 
46
//         Repo /*source*/
 
47
//         , Error /*error*/
 
48
//         , const std::string &/*description*/ )
 
49
//     { return ABORT; }
 
50
 
 
51
    virtual void finish( const ProgressData &/*task*/ )
 
52
    {}
 
53
 
 
54
  };
 
55
 
 
56
  struct ProgressReportAdaptor
 
57
  {
 
58
 
 
59
    ProgressReportAdaptor( const ProgressData::ReceiverFnc &fnc,
 
60
                           callback::SendReport<ProgressReport> &report )
 
61
      : _fnc(fnc)
 
62
      , _report(report)
 
63
      , _first(true)
 
64
    {
 
65
    }
 
66
 
 
67
    bool operator()( const ProgressData &progress )
 
68
    {
 
69
      if ( _first )
 
70
      {
 
71
        _report->start(progress);
 
72
        _first = false;
 
73
      }
 
74
 
 
75
      _report->progress(progress);
 
76
      bool value = true;
 
77
      if ( _fnc )
 
78
        value = _fnc(progress);
 
79
 
 
80
 
 
81
      if ( progress.finalReport() )
 
82
      {
 
83
        _report->finish(progress);
 
84
      }
 
85
      return value;
 
86
    }
 
87
 
 
88
    ProgressData::ReceiverFnc _fnc;
 
89
    callback::SendReport<ProgressReport> &_report;
 
90
    bool _first;
 
91
  };
 
92
 
 
93
  ////////////////////////////////////////////////////////////////////////////
 
94
 
 
95
  namespace repo
 
96
  {
 
97
    // progress for downloading a resolvable
 
98
    struct DownloadResolvableReport : public callback::ReportBase
 
99
    {
 
100
      enum Action {
 
101
        ABORT,  // abort and return error
 
102
        RETRY,  // retry
 
103
        IGNORE, // ignore this resolvable but continue
 
104
      };
 
105
 
 
106
      enum Error {
 
107
        NO_ERROR,
 
108
        NOT_FOUND,      // the requested Url was not found
 
109
        IO,             // IO error
 
110
        INVALID         // the downloaded file is invalid
 
111
      };
 
112
 
 
113
      virtual void start(
 
114
        Resolvable::constPtr /*resolvable_ptr*/
 
115
        , const Url &/*url*/
 
116
      ) {}
 
117
 
 
118
 
 
119
      // Dowmload delta rpm:
 
120
      // - path below url reported on start()
 
121
      // - expected download size (0 if unknown)
 
122
      // - download is interruptable
 
123
      // - problems are just informal
 
124
      virtual void startDeltaDownload( const Pathname & /*filename*/, const ByteCount & /*downloadsize*/ )
 
125
      {}
 
126
 
 
127
      virtual bool progressDeltaDownload( int /*value*/ )
 
128
      { return true; }
 
129
 
 
130
      virtual void problemDeltaDownload( const std::string &/*description*/ )
 
131
      {}
 
132
 
 
133
      virtual void finishDeltaDownload()
 
134
      {}
 
135
 
 
136
      // Apply delta rpm:
 
137
      // - local path of downloaded delta
 
138
      // - aplpy is not interruptable
 
139
      // - problems are just informal
 
140
      virtual void startDeltaApply( const Pathname & /*filename*/ )
 
141
      {}
 
142
 
 
143
      virtual void progressDeltaApply( int /*value*/ )
 
144
      {}
 
145
 
 
146
      virtual void problemDeltaApply( const std::string &/*description*/ )
 
147
      {}
 
148
 
 
149
      virtual void finishDeltaApply()
 
150
      {}
 
151
 
 
152
      // Dowmload patch rpm:
 
153
      // - path below url reported on start()
 
154
      // - expected download size (0 if unknown)
 
155
      // - download is interruptable
 
156
      virtual void startPatchDownload( const Pathname & /*filename*/, const ByteCount & /*downloadsize*/ )
 
157
      {}
 
158
 
 
159
      virtual bool progressPatchDownload( int /*value*/ )
 
160
      { return true; }
 
161
 
 
162
      virtual void problemPatchDownload( const std::string &/*description*/ )
 
163
      {}
 
164
 
 
165
      virtual void finishPatchDownload()
 
166
      {}
 
167
 
 
168
 
 
169
      // return false if the download should be aborted right now
 
170
      virtual bool progress(int /*value*/, Resolvable::constPtr /*resolvable_ptr*/)
 
171
      { return true; }
 
172
 
 
173
      virtual Action problem(
 
174
        Resolvable::constPtr /*resolvable_ptr*/
 
175
        , Error /*error*/
 
176
        , const std::string &/*description*/
 
177
      ) { return ABORT; }
 
178
 
 
179
      virtual void finish(Resolvable::constPtr /*resolvable_ptr*/
 
180
        , Error /*error*/
 
181
        , const std::string &/*reason*/
 
182
      ) {}
 
183
    };
 
184
 
 
185
    // progress for probing a source
 
186
    struct ProbeRepoReport : public callback::ReportBase
 
187
    {
 
188
      enum Action {
 
189
        ABORT,  // abort and return error
 
190
        RETRY   // retry
 
191
      };
 
192
 
 
193
      enum Error {
 
194
        NO_ERROR,
 
195
        NOT_FOUND,      // the requested Url was not found
 
196
        IO,             // IO error
 
197
        INVALID,                // th source is invalid
 
198
        UNKNOWN
 
199
      };
 
200
 
 
201
      virtual void start(const Url &/*url*/) {}
 
202
      virtual void failedProbe( const Url &/*url*/, const std::string &/*type*/ ) {}
 
203
      virtual void successProbe( const Url &/*url*/, const std::string &/*type*/ ) {}
 
204
      virtual void finish(const Url &/*url*/, Error /*error*/, const std::string &/*reason*/ ) {}
 
205
 
 
206
      virtual bool progress(const Url &/*url*/, int /*value*/)
 
207
      { return true; }
 
208
 
 
209
      virtual Action problem( const Url &/*url*/, Error /*error*/, const std::string &/*description*/ ) { return ABORT; }
 
210
    };
 
211
 
 
212
    struct RepoCreateReport : public callback::ReportBase
 
213
    {
 
214
      enum Action {
 
215
        ABORT,  // abort and return error
 
216
        RETRY,  // retry
 
217
        IGNORE  // skip refresh, ignore failed refresh
 
218
      };
 
219
 
 
220
      enum Error {
 
221
        NO_ERROR,
 
222
        NOT_FOUND,      // the requested Url was not found
 
223
        IO,             // IO error
 
224
        REJECTED,
 
225
        INVALID, // th source is invali
 
226
        UNKNOWN
 
227
      };
 
228
 
 
229
      virtual void start( const zypp::Url &/*url*/ ) {}
 
230
      virtual bool progress( int /*value*/ )
 
231
      { return true; }
 
232
 
 
233
      virtual Action problem(
 
234
          const zypp::Url &/*url*/
 
235
          , Error /*error*/
 
236
          , const std::string &/*description*/ )
 
237
      { return ABORT; }
 
238
 
 
239
      virtual void finish(
 
240
          const zypp::Url &/*url*/
 
241
          , Error /*error*/
 
242
          , const std::string &/*reason*/ )
 
243
      {}
 
244
    };
 
245
 
 
246
    struct RepoReport : public callback::ReportBase
 
247
    {
 
248
      enum Action {
 
249
        ABORT,  // abort and return error
 
250
        RETRY,  // retry
 
251
        IGNORE  // skip refresh, ignore failed refresh
 
252
      };
 
253
 
 
254
      enum Error {
 
255
        NO_ERROR,
 
256
        NOT_FOUND,      // the requested Url was not found
 
257
        IO,             // IO error
 
258
        INVALID         // th source is invalid
 
259
      };
 
260
 
 
261
      virtual void start( const ProgressData &/*task*/, const RepoInfo /*repo*/  ) {}
 
262
      virtual bool progress( const ProgressData &/*task*/ )
 
263
      { return true; }
 
264
 
 
265
      virtual Action problem(
 
266
          Repository /*source*/
 
267
          , Error /*error*/
 
268
          , const std::string &/*description*/ )
 
269
      { return ABORT; }
 
270
 
 
271
      virtual void finish(
 
272
          Repository /*source*/
 
273
          , const std::string &/*task*/
 
274
          , Error /*error*/
 
275
          , const std::string &/*reason*/ )
 
276
      {}
 
277
    };
 
278
 
 
279
 
 
280
    /////////////////////////////////////////////////////////////////
 
281
  } // namespace source
 
282
  ///////////////////////////////////////////////////////////////////
 
283
 
 
284
  ///////////////////////////////////////////////////////////////////
 
285
  namespace media
 
286
  {
 
287
    // media change request callback
 
288
    struct MediaChangeReport : public callback::ReportBase
 
289
    {
 
290
      enum Action {
 
291
        ABORT,  // abort and return error
 
292
        RETRY,  // retry
 
293
        IGNORE, // ignore this media in future, not available anymore
 
294
        IGNORE_ID,      // ignore wrong medium id
 
295
        CHANGE_URL,     // change media URL
 
296
        EJECT           // eject the medium
 
297
      };
 
298
 
 
299
      enum Error {
 
300
        NO_ERROR,
 
301
        NOT_FOUND,  // the medie not found at all
 
302
        IO,     // error accessing the media
 
303
        INVALID, // media is broken
 
304
        WRONG,  // wrong media, need a different one
 
305
        IO_SOFT       /**< IO error which can happen on worse connection like timeout exceed */
 
306
      };
 
307
 
 
308
      /**
 
309
       *
 
310
       * \param url         in: url for which the media is requested,
 
311
       *                    out: url to use instead of the original one
 
312
       * \param mediumNr    requested medium number
 
313
       * \param label       label of requested medium
 
314
       * \param error       type of error from \ref Error enum
 
315
       * \param description error message (media not desired or error foo occured)
 
316
       * \param devices     list of the available devices (for eject)
 
317
       * \param dev_current in: index of the currently used device in the \a devices list
 
318
       *                    out: index of the devices to be ejected in the \a devices list
 
319
       * \return \ref Action (ABORT by default)
 
320
       */
 
321
      virtual Action requestMedia(
 
322
        Url & /* url (I/O parameter) */
 
323
        , unsigned /*mediumNr*/
 
324
        , const std::string & /* label */
 
325
        , Error /*error*/
 
326
        , const std::string & /*description*/
 
327
        , const std::vector<std::string> & /* devices */
 
328
        , unsigned int & /* dev_current (I/O param) */
 
329
      ) { return ABORT; }
 
330
    };
 
331
 
 
332
    // progress for downloading a file
 
333
    struct DownloadProgressReport : public callback::ReportBase
 
334
    {
 
335
        enum Action {
 
336
          ABORT,  // abort and return error
 
337
          RETRY,        // retry
 
338
          IGNORE        // ignore the failure
 
339
        };
 
340
 
 
341
        enum Error {
 
342
          NO_ERROR,
 
343
          NOT_FOUND,    // the requested Url was not found
 
344
          IO,           // IO error
 
345
          ACCESS_DENIED, // user authent. failed while accessing restricted file
 
346
          ERROR // other error
 
347
        };
 
348
 
 
349
        virtual void start( const Url &/*file*/, Pathname /*localfile*/ ) {}
 
350
 
 
351
        /**
 
352
         * Download progress.
 
353
         *
 
354
         * \param value        Percentage value.
 
355
         * \param file         File URI.
 
356
         * \param dbps_avg     Average download rate so far. -1 if unknown.
 
357
         * \param dbps_current Current download (cca last 1 sec). -1 if unknown.
 
358
         */
 
359
        virtual bool progress(int /*value*/, const Url &/*file*/,
 
360
                              double dbps_avg = -1,
 
361
                              double dbps_current = -1)
 
362
        { return true; }
 
363
 
 
364
        virtual Action problem(
 
365
          const Url &/*file*/
 
366
          , Error /*error*/
 
367
          , const std::string &/*description*/
 
368
        ) { return ABORT; }
 
369
 
 
370
        virtual void finish(
 
371
          const Url &/*file*/
 
372
          , Error /*error*/
 
373
          , const std::string &/*reason*/
 
374
        ) {}
 
375
    };
 
376
 
 
377
    // authentication issues report
 
378
    struct AuthenticationReport : public callback::ReportBase
 
379
    {
 
380
      /**
 
381
       * Prompt for authentication data.
 
382
       *
 
383
       * \param url       URL which required the authentication
 
384
       * \param msg       prompt text
 
385
       * \param auth_data input/output object for handling authentication
 
386
       *        data. As an input parameter auth_data can be prefilled with
 
387
       *        username (from previous try) or auth_type (available
 
388
       *        authentication methods aquired from server (only CurlAuthData)).
 
389
       *        As an output parameter it serves for sending username, pasword
 
390
       *        or other special data (derived AuthData objects).
 
391
       * \return true if user chooses to continue with authentication,
 
392
       *         false otherwise
 
393
       */
 
394
      virtual bool prompt(const Url & /* url */,
 
395
        const std::string & /* msg */,
 
396
        AuthData & /* auth_data */)
 
397
      {
 
398
        return false;
 
399
      }
 
400
    };
 
401
 
 
402
    /////////////////////////////////////////////////////////////////
 
403
  } // namespace media
 
404
  ///////////////////////////////////////////////////////////////////
 
405
 
 
406
  ///////////////////////////////////////////////////////////////////
 
407
  namespace target
 
408
  {
 
409
    /** Request to display the pre commit message of a patch. */
 
410
    struct PatchMessageReport : public callback::ReportBase
 
411
    {
 
412
      /** Display \c patch->message().
 
413
       * Return \c true to continue, \c false to abort commit.
 
414
      */
 
415
      virtual bool show( Patch::constPtr & /*patch*/ )
 
416
      { return true; }
 
417
    };
 
418
 
 
419
    /** Indicate execution of a patch script. This is a sort of
 
420
     * \c %post script shipped by a package and to be executed
 
421
     * after the package was installed.
 
422
    */
 
423
    struct PatchScriptReport : public callback::ReportBase
 
424
    {
 
425
      enum Notify { OUTPUT, PING };
 
426
      enum Action {
 
427
        ABORT,  // abort commit and return error
 
428
        RETRY,  // (re)try to execute this script
 
429
        IGNORE  // ignore any failue and continue
 
430
      };
 
431
 
 
432
      /** Start executing the script provided by package.
 
433
      */
 
434
      virtual void start( const Package::constPtr & /*package*/,
 
435
                          const Pathname & /*script path*/ )
 
436
      {}
 
437
      /** Progress provides the script output. If the script is quiet,
 
438
       * from time to time still-alive pings are sent to the ui. Returning \c FALSE
 
439
       * aborts script execution.
 
440
      */
 
441
      virtual bool progress( Notify /*OUTPUT or PING*/,
 
442
                             const std::string & /*output*/ = std::string() )
 
443
      { return true; }
 
444
      /** Report error. */
 
445
      virtual Action problem( const std::string & /*description*/ )
 
446
      { return ABORT; }
 
447
      /** Report success. */
 
448
      virtual void finish()
 
449
      {}
 
450
    };
 
451
 
 
452
    ///////////////////////////////////////////////////////////////////
 
453
    /// \class FindFileConflictstReport
 
454
    /// \brief Check for package file conflicts in commit (after download)
 
455
    ///
 
456
    /// File conflict check requires that all packages are downloaded and
 
457
    /// now available in the cache (need to access the filelists). Missing
 
458
    /// packages are omitted from check and their number is reported in
 
459
    /// \a noFilelist_r. This usually happens if download mode 'as-needed'
 
460
    /// is used.
 
461
    ///////////////////////////////////////////////////////////////////
 
462
    struct FindFileConflictstReport : public callback::ReportBase
 
463
    {
 
464
      /**
 
465
       * \param progress_r      Progress counter for packages to check.
 
466
       * \return \c true to continue, \c false upon user abort request.
 
467
       */
 
468
      virtual bool start( const ProgressData & progress_r )
 
469
      { return true; }
 
470
 
 
471
      /**
 
472
       * \param progress_r      Progress counter for packages to check.
 
473
       * \param noFilelist_r    Queue of so far skipped solvables (no filelist/not yet downloaded).
 
474
       * \return \c true to continue, \c false upon user abort request.
 
475
       */
 
476
      virtual bool progress( const ProgressData & progress_r, const sat::Queue & noFilelist_r )
 
477
      { return true; }
 
478
 
 
479
      /**
 
480
       * \param progress_r      Progress counter for packages to check.
 
481
       * \param noFilelist_r    Queue of skipped solvables (no filelist/not yet downloaded).
 
482
       * \param conflicts_r     File conflits queue.
 
483
       * \return \c true to continue, \c false upon user abort request.
 
484
       */
 
485
      virtual bool result( const ProgressData & progress_r, const sat::Queue & noFilelist_r, const sat::FileConflicts & conflicts_r )
 
486
      { return true; }
 
487
    };
 
488
 
 
489
 
 
490
    ///////////////////////////////////////////////////////////////////
 
491
    namespace rpm
 
492
    {
 
493
 
 
494
      // progress for installing a resolvable
 
495
      struct InstallResolvableReport : public callback::ReportBase
 
496
      {
 
497
        enum Action {
 
498
          ABORT,  // abort and return error
 
499
          RETRY,        // retry
 
500
          IGNORE        // ignore the failure
 
501
        };
 
502
 
 
503
        enum Error {
 
504
          NO_ERROR,
 
505
          NOT_FOUND,    // the requested Url was not found
 
506
          IO,           // IO error
 
507
          INVALID               // th resolvable is invalid
 
508
        };
 
509
 
 
510
        // the level of RPM pushing
 
511
        /** \deprecated We fortunately no longer do 3 attempts. */
 
512
        enum RpmLevel {
 
513
            RPM,
 
514
            RPM_NODEPS,
 
515
            RPM_NODEPS_FORCE    //!< only this one used
 
516
        };
 
517
 
 
518
        virtual void start(
 
519
          Resolvable::constPtr /*resolvable*/
 
520
        ) {}
 
521
 
 
522
        virtual bool progress(int /*value*/, Resolvable::constPtr /*resolvable*/)
 
523
        { return true; }
 
524
 
 
525
        virtual Action problem(
 
526
          Resolvable::constPtr /*resolvable*/
 
527
          , Error /*error*/
 
528
          , const std::string &/*description*/
 
529
          , RpmLevel /*level*/
 
530
        ) { return ABORT; }
 
531
 
 
532
        virtual void finish(
 
533
          Resolvable::constPtr /*resolvable*/
 
534
          , Error /*error*/
 
535
          , const std::string &/*reason*/
 
536
          , RpmLevel /*level*/
 
537
        ) {}
 
538
      };
 
539
 
 
540
      // progress for removing a resolvable
 
541
      struct RemoveResolvableReport : public callback::ReportBase
 
542
      {
 
543
        enum Action {
 
544
          ABORT,  // abort and return error
 
545
          RETRY,        // retry
 
546
          IGNORE        // ignore the failure
 
547
        };
 
548
 
 
549
        enum Error {
 
550
          NO_ERROR,
 
551
          NOT_FOUND,    // the requested Url was not found
 
552
          IO,           // IO error
 
553
          INVALID               // th resolvable is invalid
 
554
        };
 
555
 
 
556
        virtual void start(
 
557
          Resolvable::constPtr /*resolvable*/
 
558
        ) {}
 
559
 
 
560
        virtual bool progress(int /*value*/, Resolvable::constPtr /*resolvable*/)
 
561
        { return true; }
 
562
 
 
563
        virtual Action problem(
 
564
          Resolvable::constPtr /*resolvable*/
 
565
          , Error /*error*/
 
566
          , const std::string &/*description*/
 
567
        ) { return ABORT; }
 
568
 
 
569
        virtual void finish(
 
570
          Resolvable::constPtr /*resolvable*/
 
571
          , Error /*error*/
 
572
          , const std::string &/*reason*/
 
573
        ) {}
 
574
      };
 
575
 
 
576
      // progress for rebuilding the database
 
577
      struct RebuildDBReport : public callback::ReportBase
 
578
      {
 
579
        enum Action {
 
580
          ABORT,  // abort and return error
 
581
          RETRY,        // retry
 
582
          IGNORE        // ignore the failure
 
583
        };
 
584
 
 
585
        enum Error {
 
586
          NO_ERROR,
 
587
          FAILED                // failed to rebuild
 
588
        };
 
589
 
 
590
        virtual void start(Pathname /*path*/) {}
 
591
 
 
592
        virtual bool progress(int /*value*/, Pathname /*path*/)
 
593
        { return true; }
 
594
 
 
595
        virtual Action problem(
 
596
          Pathname /*path*/
 
597
         , Error /*error*/
 
598
         , const std::string &/*description*/
 
599
        ) { return ABORT; }
 
600
 
 
601
        virtual void finish(
 
602
          Pathname /*path*/
 
603
          , Error /*error*/
 
604
          , const std::string &/*reason*/
 
605
        ) {}
 
606
      };
 
607
 
 
608
      // progress for converting the database
 
609
      struct ConvertDBReport : public callback::ReportBase
 
610
      {
 
611
        enum Action {
 
612
          ABORT,  // abort and return error
 
613
          RETRY,        // retry
 
614
          IGNORE        // ignore the failure
 
615
        };
 
616
 
 
617
        enum Error {
 
618
          NO_ERROR,
 
619
          FAILED                // conversion failed
 
620
        };
 
621
 
 
622
        virtual void start(
 
623
          Pathname /*path*/
 
624
        ) {}
 
625
 
 
626
        virtual bool progress(int /*value*/, Pathname /*path*/)
 
627
        { return true; }
 
628
 
 
629
        virtual Action problem(
 
630
          Pathname /*path*/
 
631
          , Error /*error*/
 
632
         , const std::string &/*description*/
 
633
        ) { return ABORT; }
 
634
 
 
635
        virtual void finish(
 
636
          Pathname /*path*/
 
637
          , Error /*error*/
 
638
          , const std::string &/*reason*/
 
639
        ) {}
 
640
      };
 
641
 
 
642
      /////////////////////////////////////////////////////////////////
 
643
    } // namespace rpm
 
644
    ///////////////////////////////////////////////////////////////////
 
645
 
 
646
    /////////////////////////////////////////////////////////////////
 
647
  } // namespace target
 
648
  ///////////////////////////////////////////////////////////////////
 
649
 
 
650
  class PoolQuery;
 
651
 
 
652
  /** \name Locks */
 
653
  //@{
 
654
  /**
 
655
   * Callback for cleaning locks which doesn't lock anything in pool.
 
656
   */
 
657
 
 
658
  struct CleanEmptyLocksReport : public callback::ReportBase
 
659
  {
 
660
    /**
 
661
     * action performed by cleaning api to specific lock
 
662
     */
 
663
    enum Action {
 
664
      ABORT,  /**< abort and return error */
 
665
      DELETE, /**< delete empty lock    */
 
666
      IGNORE  /**< skip empty lock */
 
667
    };
 
668
 
 
669
    /**
 
670
     * result of cleaning
 
671
     */
 
672
    enum Error {
 
673
      NO_ERROR, /**< no problem */
 
674
      ABORTED /** cleaning aborted by user */
 
675
    };
 
676
 
 
677
    /**
 
678
     * cleaning is started
 
679
     */
 
680
    virtual void start(
 
681
    ) {}
 
682
 
 
683
    /**
 
684
     * progress of cleaning specifies in percents
 
685
     * \return if continue
 
686
     */
 
687
    virtual bool progress(int /*value*/)
 
688
    { return true; }
 
689
 
 
690
    /**
 
691
     * When find empty lock ask what to do with it
 
692
     * \return action
 
693
     */
 
694
    virtual Action execute(
 
695
        const PoolQuery& /*error*/
 
696
     ) { return DELETE; }
 
697
 
 
698
      /**
 
699
       * cleaning is done
 
700
       */
 
701
     virtual void finish(
 
702
       Error /*error*/
 
703
      ) {}
 
704
 
 
705
  };
 
706
 
 
707
  /**
 
708
   * this callback handles merging old locks with newly added or removed
 
709
   */
 
710
  struct SavingLocksReport : public callback::ReportBase
 
711
  {
 
712
    /**
 
713
     * action for old lock which is in conflict
 
714
     * \see ConflictState
 
715
     */
 
716
    enum Action {
 
717
      ABORT,  /**< abort and return error*/
 
718
      DELETE, /**< delete conflicted lock    */
 
719
      IGNORE  /**< skip conflict lock */
 
720
    };
 
721
 
 
722
    /**
 
723
     * result of merging
 
724
     */
 
725
    enum Error {
 
726
      NO_ERROR, /**< no problem */
 
727
      ABORTED  /**< cleaning aborted by user */
 
728
    };
 
729
 
 
730
    /**
 
731
     * type of conflict of old and new lock
 
732
     */
 
733
    enum ConflictState{
 
734
      SAME_RESULTS, /**< locks lock same item in pool but his parameters is different */
 
735
      INTERSECT /**< locks lock some file and unlocking lock unlock only part
 
736
      * of iti, so removing old lock can unlock more items in pool */
 
737
    };
 
738
 
 
739
    virtual void start() {}
 
740
 
 
741
    /**
 
742
     * merging still live
 
743
     * \return if continue
 
744
     */
 
745
    virtual bool progress()
 
746
    { return true; }
 
747
 
 
748
    /**
 
749
     * When user unlock something which is locked by non-identical query
 
750
     */
 
751
    virtual Action conflict(
 
752
         const PoolQuery&, /**< problematic query*/
 
753
       ConflictState
 
754
     ) { return DELETE; }
 
755
 
 
756
     virtual void finish(
 
757
       Error /*error*/
 
758
      ) {}
 
759
  };
 
760
 
 
761
 
 
762
  /////////////////////////////////////////////////////////////////
 
763
} // namespace zypp
 
764
///////////////////////////////////////////////////////////////////
 
765
 
 
766
#endif // ZYPP_ZYPPCALLBACKS_H