libzypp  17.38.17
ZYppCallbacks.h
Go to the documentation of this file.
1 /*---------------------------------------------------------------------\
2 | ____ _ __ __ ___ |
3 | |__ / \ / / . \ . \ |
4 | / / \ V /| _/ _/ |
5 | / /__ | | | | | | |
6 | /_____||_| |_| |_| |
7 | |
8 \---------------------------------------------------------------------*/
12 #ifndef ZYPP_ZYPPCALLBACKS_H
13 #define ZYPP_ZYPPCALLBACKS_H
14 
16 #include <zypp/Callback.h>
17 #include <zypp-core/UserData.h>
18 #include <zypp/Resolvable.h>
19 #include <zypp/RepoInfo.h>
20 #include <zypp-core/Pathname.h>
21 #include <zypp/Package.h>
22 #include <zypp/Patch.h>
23 #include <zypp-core/Url.h>
24 #include <zypp-core/ui/ProgressData>
25 #include <zypp-media/auth/AuthData>
26 #include <zypp-curl/auth/CurlAuthData> // bsc#1194597: CurlAuthData must be exposed for zypper
27 
29 namespace zypp
30 {
31 
33  namespace sat
34  {
35  class Queue;
36  class FileConflicts;
37  } // namespace sat
39 
41  {
42  virtual void start( const ProgressData &/*task*/ )
43  {}
44 
45  virtual bool progress( const ProgressData &/*task*/ )
46  { return true; }
47 
48 // virtual Action problem(
49 // Repo /*source*/
50 // , Error /*error*/
51 // , const std::string &/*description*/ )
52 // { return ABORT; }
53 
54  virtual void finish( const ProgressData &/*task*/ )
55  {}
56 
57  };
58 
60  {
61 
63  : _report(report)
64  , _first(true)
65  {}
66 
69  : _fnc(fnc)
70  , _report(report)
71  , _first(true)
72  {}
73 
74  bool operator()( const ProgressData &progress )
75  {
76  if ( _first )
77  {
78  _report->start(progress);
79  _first = false;
80  }
81 
82  bool value = _report->progress(progress);
83  if ( _fnc )
84  value &= _fnc(progress);
85 
86  if ( progress.finalReport() )
87  {
88  _report->finish(progress);
89  }
90  return value;
91  }
92 
95  bool _first;
96  };
97 
99 
100  namespace repo
101  {
102  // progress for downloading a resolvable
104  {
105  enum Action {
106  ABORT, // abort and return error
107  RETRY, // retry
108  IGNORE, // ignore this resolvable but continue
109  };
110 
111  enum Error {
113  NOT_FOUND, // the requested Url was not found
114  IO, // IO error
115  INVALID // the downloaded file is invalid
116  };
117 
121  virtual void infoInCache( Resolvable::constPtr res_r, const Pathname & localfile_r )
122  {}
123 
124  virtual void start(
125  Resolvable::constPtr /*resolvable_ptr*/
126  , const Url &/*url*/
127  ) {}
128 
129 
130  // Dowmload delta rpm:
131  // - path below url reported on start()
132  // - expected download size (0 if unknown)
133  // - download is interruptable
134  // - problems are just informal
135  virtual void startDeltaDownload( const Pathname & /*filename*/, const ByteCount & /*downloadsize*/ )
136  {}
137 
138  virtual bool progressDeltaDownload( int /*value*/ )
139  { return true; }
140 
141  virtual void problemDeltaDownload( const std::string &/*description*/ )
142  {}
143 
144  virtual void finishDeltaDownload()
145  {}
146 
147  // Apply delta rpm:
148  // - local path of downloaded delta
149  // - aplpy is not interruptable
150  // - problems are just informal
151  virtual void startDeltaApply( const Pathname & /*filename*/ )
152  {}
153 
154  virtual void progressDeltaApply( int /*value*/ )
155  {}
156 
157  virtual void problemDeltaApply( const std::string &/*description*/ )
158  {}
159 
160  virtual void finishDeltaApply()
161  {}
162 
163  // return false if the download should be aborted right now
164  virtual bool progress(int /*value*/, Resolvable::constPtr /*resolvable_ptr*/)
165  { return true; }
166 
167  virtual Action problem(
168  Resolvable::constPtr /*resolvable_ptr*/
169  , Error /*error*/
170  , const std::string &/*description*/
171  ) { return ABORT; }
172 
173 
189  virtual void pkgGpgCheck( const UserData & userData_r = UserData() )
190  {}
191 
192  virtual void finish(Resolvable::constPtr /*resolvable_ptr*/
193  , Error /*error*/
194  , const std::string &/*reason*/
195  ) {}
196  };
197 
198  // progress for probing a source
201  {
202  enum Action {
203  ABORT, // abort and return error
204  RETRY // retry
205  };
206 
207  enum Error {
209  NOT_FOUND, // the requested Url was not found
210  IO, // IO error
211  INVALID, // th source is invalid
213  };
214 
215  virtual void start(const Url &/*url*/) {}
216  virtual void failedProbe( const Url &/*url*/, const std::string &/*type*/ ) {}
217  virtual void successProbe( const Url &/*url*/, const std::string &/*type*/ ) {}
218  virtual void finish(const Url &/*url*/, Error /*error*/, const std::string &/*reason*/ ) {}
219 
220  virtual bool progress(const Url &/*url*/, int /*value*/)
221  { return true; }
222 
223  virtual Action problem( const Url &/*url*/, Error /*error*/, const std::string &/*description*/ ) { return ABORT; }
224  };
225 
228  {
229  enum Action {
230  ABORT, // abort and return error
231  RETRY, // retry
232  IGNORE // skip refresh, ignore failed refresh
233  };
234 
235  enum Error {
237  NOT_FOUND, // the requested Url was not found
238  IO, // IO error
240  INVALID, // th source is invali
242  };
243 
244  virtual void start( const zypp::Url &/*url*/ ) {}
245  virtual bool progress( int /*value*/ )
246  { return true; }
247 
248  virtual Action problem(
249  const zypp::Url &/*url*/
250  , Error /*error*/
251  , const std::string &/*description*/ )
252  { return ABORT; }
253 
254  virtual void finish(
255  const zypp::Url &/*url*/
256  , Error /*error*/
257  , const std::string &/*reason*/ )
258  {}
259  };
260 
263  {
264  enum Action {
265  ABORT, // abort and return error
266  RETRY, // retry
267  IGNORE // skip refresh, ignore failed refresh
268  };
269 
270  enum Error {
272  NOT_FOUND, // the requested Url was not found
273  IO, // IO error
274  INVALID // th source is invalid
275  };
276 
277  virtual void start( const ProgressData &/*task*/, const RepoInfo /*repo*/ ) {}
278  virtual bool progress( const ProgressData &/*task*/ )
279  { return true; }
280 
281  virtual Action problem(
282  Repository /*source*/
283  , Error /*error*/
284  , const std::string &/*description*/ )
285  { return ABORT; }
286 
287  virtual void finish(
288  Repository /*source*/
289  , const std::string &/*task*/
290  , Error /*error*/
291  , const std::string &/*reason*/ )
292  {}
293  };
294 
295 
297  } // namespace source
299 
301  namespace media
302  {
303  // media change request callback
305  {
306  enum Action {
307  ABORT, // abort and return error
308  RETRY, // retry
309  IGNORE, // ignore this media in future, not available anymore
310  IGNORE_ID, // ignore wrong medium id
311  CHANGE_URL, // change media URL
312  EJECT // eject the medium
313  };
314 
315  enum Error {
317  NOT_FOUND, // the medie not found at all
318  IO, // error accessing the media
319  INVALID, // media is broken
320  WRONG, // wrong media, need a different one
321  IO_SOFT
322  };
323 
338  Url & /* url (I/O parameter) */
339  , unsigned /*mediumNr*/
340  , const std::string & /* label */
341  , Error /*error*/
342  , const std::string & /*description*/
343  , const std::vector<std::string> & /* devices */
344  , unsigned int & /* dev_current (I/O param) */
345  ) { return ABORT; }
346  };
347 
354  {
356  ScopedDisableMediaChangeReport( bool condition_r = true );
357  private:
358  shared_ptr<callback::TempConnect<media::MediaChangeReport> > _guard;
359  };
360 
361  // progress for downloading a file
363  {
364  enum Action {
365  ABORT, // abort and return error
366  RETRY, // retry
367  IGNORE // ignore the failure
368  };
369 
370  enum Error {
372  NOT_FOUND, // the requested Url was not found
373  IO, // IO error
374  ACCESS_DENIED, // user authent. failed while accessing restricted file
375  ERROR // other error
376  };
377 
378  virtual void start( const Url &/*file*/, Pathname /*localfile*/ ) {}
379 
388  virtual bool progress(int /*value*/, const Url &/*file*/,
389  double dbps_avg = -1,
390  double dbps_current = -1)
391  { return true; }
392 
393  virtual Action problem(
394  const Url &/*file*/
395  , Error /*error*/
396  , const std::string &/*description*/
397  ) { return ABORT; }
398 
399  virtual void finish(
400  const Url &/*file*/
401  , Error /*error*/
402  , const std::string &/*reason*/
403  ) {}
404  };
405 
406  // progress for concurrently preloading a entire commit
408  {
409  enum Error {
411  NOT_FOUND, // the requested Url was not found
412  IO, // IO error
413  ACCESS_DENIED, // user authent. failed while accessing restricted file
414  ERROR // other error
415  };
416 
420  virtual void start( const UserData &userData = UserData() ) {}
421 
433  virtual bool progress( int value, const UserData &userData = UserData() )
434  { return true; }
435 
443  virtual void fileStart(
444  const Pathname &localfile,
445  const UserData &userData = UserData()
446  ) {}
447 
456  virtual void fileDone(
457  const Pathname &localfile,
458  Error error,
459  const UserData &userData = UserData()
460  ) {}
461 
462  enum Result {
463  SUCCESS, //< everything was fetched as expected
464  MISS //< some files are missing
465  };
466 
470  virtual void finish( Result res, const UserData &userData = UserData() ) {}
471  };
472 
473  // authentication issues report
475  {
490  virtual bool prompt(const Url & /* url */,
491  const std::string & /* msg */,
492  AuthData & /* auth_data */)
493  {
494  return false;
495  }
496  };
497 
499  } // namespace media
501 
503  namespace target
504  {
507  {
511  virtual bool show( Patch::constPtr & /*patch*/ )
512  { return true; }
513  };
514 
520  {
521  enum Notify { OUTPUT, PING };
522  enum Action {
523  ABORT, // abort commit and return error
524  RETRY, // (re)try to execute this script
525  IGNORE // ignore any failue and continue
526  };
527 
530  virtual void start( const Package::constPtr & /*package*/,
531  const Pathname & /*script path*/ )
532  {}
537  virtual bool progress( Notify /*OUTPUT or PING*/,
538  const std::string & /*output*/ = std::string() )
539  { return true; }
541  virtual Action problem( const std::string & /*description*/ )
542  { return ABORT; }
544  virtual void finish()
545  {}
546  };
547 
559  {
564  virtual bool start( const ProgressData & progress_r )
565  { return true; }
566 
572  virtual bool progress( const ProgressData & progress_r, const sat::Queue & noFilelist_r )
573  { return true; }
574 
581  virtual bool result( const ProgressData & progress_r, const sat::Queue & noFilelist_r, const sat::FileConflicts & conflicts_r )
582  { return true; }
583  };
584 
585 
604  {
608  virtual bool start( const UserData & = UserData() /*userdata*/ ) { return true; }
609 
613  virtual void end ( const UserData & = UserData() /*userdata*/ ) { }
614 
615  // added for future use to avoid breaking compatibility
616  virtual void step ( const UserData & = UserData() /*userdata*/ ) { }
617  };
618 
620  namespace rpm
621  {
622 
623  // progress for installing a resolvable
625  {
626  enum Action {
627  ABORT, // abort and return error
628  RETRY, // retry
629  IGNORE // ignore the failure
630  };
631 
632  enum Error {
634  NOT_FOUND, // the requested Url was not found
635  IO, // IO error
636  INVALID // th resolvable is invalid
637  };
638 
639  // the level of RPM pushing
641  enum RpmLevel {
644  RPM_NODEPS_FORCE
645  };
646 
647  virtual void start(
648  Resolvable::constPtr /*resolvable*/
649  ) {}
650 
651  virtual bool progress(int /*value*/, Resolvable::constPtr /*resolvable*/)
652  { return true; }
653 
654  virtual Action problem(
655  Resolvable::constPtr /*resolvable*/
656  , Error /*error*/
657  , const std::string &/*description*/
658  , RpmLevel /*level*/
659  ) { return ABORT; }
660 
661  virtual void finish(
662  Resolvable::constPtr /*resolvable*/
663  , Error /*error*/
664  , const std::string &/*reason*/
665  , RpmLevel /*level*/
666  ) {}
667 
674  static const UserData::ContentType contentRpmout ZYPP_API;
675  };
676 
677  // progress for removing a resolvable
679  {
680  enum Action {
681  ABORT, // abort and return error
682  RETRY, // retry
683  IGNORE // ignore the failure
684  };
685 
686  enum Error {
688  NOT_FOUND, // the requested Url was not found
689  IO, // IO error
690  INVALID // th resolvable is invalid
691  };
692 
693  virtual void start(
694  Resolvable::constPtr /*resolvable*/
695  ) {}
696 
697  virtual bool progress(int /*value*/, Resolvable::constPtr /*resolvable*/)
698  { return true; }
699 
700  virtual Action problem(
701  Resolvable::constPtr /*resolvable*/
702  , Error /*error*/
703  , const std::string &/*description*/
704  ) { return ABORT; }
705 
706  virtual void finish(
707  Resolvable::constPtr /*resolvable*/
708  , Error /*error*/
709  , const std::string &/*reason*/
710  ) {}
711 
715  static const UserData::ContentType contentRpmout ZYPP_API;
716  };
717 
718  // progress for rebuilding the database
720  {
721  enum Action {
722  ABORT, // abort and return error
723  RETRY, // retry
724  IGNORE // ignore the failure
725  };
726 
727  enum Error {
729  FAILED // failed to rebuild
730  };
731 
732  virtual void start(Pathname /*path*/) {}
733 
734  virtual bool progress(int /*value*/, Pathname /*path*/)
735  { return true; }
736 
737  virtual Action problem(
738  Pathname /*path*/
739  , Error /*error*/
740  , const std::string &/*description*/
741  ) { return ABORT; }
742 
743  virtual void finish(
744  Pathname /*path*/
745  , Error /*error*/
746  , const std::string &/*reason*/
747  ) {}
748  };
749 
750 #if LEGACY(17)
751  // progress for converting the database
753  struct ZYPP_DEPRECATED ConvertDBReport : public callback::ReportBase
754  {
755  enum Action {
756  ABORT, // abort and return error
757  RETRY, // retry
758  IGNORE // ignore the failure
759  };
760 
761  enum Error {
762  NO_ERROR,
763  FAILED // conversion failed
764  };
765 
766  virtual void start( Pathname /*path*/ )
767  {}
768 
769  virtual bool progress( int/*value*/, Pathname/*path*/ )
770  { return true; }
771 
772  virtual Action problem( Pathname/*path*/, Error/*error*/, const std::string &/*description*/ )
773  { return ABORT; }
774 
775  virtual void finish( Pathname/*path*/, Error/*error*/, const std::string &/*reason*/ )
776  {}
777  };
778 #endif
779 
789  {
795  static const UserData::ContentType contentLogline ZYPP_API;
797  enum class loglevel { dbg, msg, war, err, crt };
799  static const char *const loglevelPrefix( loglevel level_r )
800  {
801  switch ( level_r ) {
802  case loglevel::crt: return "fatal error: ";
803  case loglevel::err: return "error: ";
804  case loglevel::war: return "warning: ";
805  case loglevel::msg: return "";
806  case loglevel::dbg: return "D: ";
807  }
808  return "";
809  }
810  };
811 
812  // Generic transaction reports, this is used for verifying and preparing tasks, the name param
813  // for the start function defines which report we are looking at
815  {
816  enum Error {
817  NO_ERROR, // everything went perfectly fine
818  FINISHED_WITH_ERRORS, // the transaction was finished, but some errors happened
819  FAILED // the transaction failed completely
820  };
821 
822  virtual void start(
823  const std::string &/*name*/,
824  const UserData & = UserData() /*userdata*/
825  ) {}
826 
827  virtual void progress(
828  int /*value*/,
829  const UserData & = UserData() /*userdata*/
830  ) { }
831 
832  virtual void finish(
833  Error /*error*/,
834  const UserData & = UserData() /*userdata*/
835  ) {}
836 
841  static const UserData::ContentType contentRpmout ZYPP_API;
842  };
843 
844 
845  // progress for installing a resolvable in single transaction mode
847  {
848  enum Error {
850  NOT_FOUND, // the requested Url was not found
851  IO, // IO error
852  INVALID // th resolvable is invalid
853  };
854 
855  virtual void start(
856  Resolvable::constPtr /*resolvable*/,
857  const UserData & = UserData() /*userdata*/
858  ) {}
859 
860  virtual void progress(
861  int /*value*/,
862  Resolvable::constPtr /*resolvable*/,
863  const UserData & = UserData() /*userdata*/
864  ) { return; }
865 
866  virtual void finish(
867  Resolvable::constPtr /*resolvable*/
868  , Error /*error*/,
869  const UserData & = UserData() /*userdata*/
870  ) {}
871 
877  static const UserData::ContentType contentRpmout ZYPP_API;
878  };
879 
880  // progress for removing a resolvable in single transaction mode
882  {
883  enum Error {
885  NOT_FOUND, // the requested Url was not found
886  IO, // IO error
887  INVALID // th resolvable is invalid
888  };
889 
890  virtual void start(
891  Resolvable::constPtr /*resolvable*/,
892  const UserData & = UserData() /*userdata*/
893  ) {}
894 
895  virtual void progress(
896  int /*value*/,
897  Resolvable::constPtr /*resolvable*/,
898  const UserData & = UserData() /*userdata*/
899  ) { return; }
900 
901  virtual void finish(
902  Resolvable::constPtr /*resolvable*/
903  , Error /*error*/
904  , const UserData & = UserData() /*userdata*/
905  ) {}
906 
910  static const UserData::ContentType contentRpmout ZYPP_API;
911  };
912 
913  // progress for cleaning up the old version of a package after it was upgraded to a new version
915  {
916  enum Error {
917  NO_ERROR
918  };
919 
920  virtual void start(
921  const std::string & /*nvra*/,
922  const UserData & = UserData() /*userdata*/
923  ) {}
924 
925  virtual void progress(
926  int /*value*/,
927  const UserData & = UserData() /*userdata*/
928  ) { return; }
929 
930  virtual void finish(
931  Error /*error*/,
932  const UserData & = UserData() /*userdata*/
933  ) {}
934 
938  static const UserData::ContentType contentRpmout ZYPP_API;
939  };
940 
941 
942  // progress for script thats executed during a commit transaction
943  // the resolvable can be null, for things like posttrans scripts
945  {
946  enum Error {
949  CRITICAL // the script failure prevented solvable installation
950  };
951 
952  virtual void start(
953  const std::string & /*scriptType*/,
954  const std::string & /*packageName ( can be empty )*/,
955  Resolvable::constPtr /*resolvable ( can be null )*/,
956  const UserData & = UserData() /*userdata*/
957  ) {}
958 
959  virtual void progress(
960  int /*value*/,
961  Resolvable::constPtr /*resolvable*/,
962  const UserData & = UserData() /*userdata*/
963  ) { return; }
964 
965  virtual void finish(
966  Resolvable::constPtr /*resolvable*/
967  , Error /*error*/,
968  const UserData & = UserData() /*userdata*/
969  ) {}
970 
976  static const UserData::ContentType contentRpmout ZYPP_API;
977  };
978 
980  } // namespace rpm
982 
984  } // namespace target
986 
987  class PoolQuery;
988 
996  {
1000  enum Action {
1003  IGNORE
1004  };
1005 
1009  enum Error {
1011  ABORTED
1012  };
1013 
1017  virtual void start(
1018  ) {}
1019 
1024  virtual bool progress(int /*value*/)
1025  { return true; }
1026 
1031  virtual Action execute(
1032  const PoolQuery& /*error*/
1033  ) { return DELETE; }
1034 
1038  virtual void finish(
1039  Error /*error*/
1040  ) {}
1041 
1042  };
1043 
1048  {
1053  enum Action {
1056  IGNORE
1057  };
1058 
1062  enum Error {
1064  ABORTED
1065  };
1066 
1072  INTERSECT
1074  };
1075 
1076  virtual void start() {}
1077 
1082  virtual bool progress()
1083  { return true; }
1084 
1088  virtual Action conflict(
1089  const PoolQuery&,
1091  ) { return DELETE; }
1092 
1093  virtual void finish(
1094  Error /*error*/
1095  ) {}
1096  };
1097 
1103  {
1104  public:
1106  struct EMsgTypeDef {
1107  enum Enum { debug, info, warning, error, important, data };
1108  };
1109  typedef base::EnumClass<EMsgTypeDef> MsgType;
1110 
1113 
1115 
1116  public:
1118  virtual bool message( MsgType type_r, const std::string & msg_r, const UserData & userData_r ) const
1119  { return true; }
1120 
1121 
1125  static callback::SendReport<JobReport> & instance(); // impl in ZYppImpl.cc
1126 
1128  static bool debug( const std::string & msg_r, const UserData & userData_r = UserData() )
1129  { return instance()->message( MsgType::debug, msg_r, userData_r ); }
1130 
1132  static bool info( const std::string & msg_r, const UserData & userData_r = UserData() )
1133  { return instance()->message( MsgType::info, msg_r, userData_r ); }
1134 
1136  static bool warning( const std::string & msg_r, const UserData & userData_r = UserData() )
1137  { return instance()->message( MsgType::warning, msg_r, userData_r ); }
1138 
1140  static bool error( const std::string & msg_r, const UserData & userData_r = UserData() )
1141  { return instance()->message( MsgType::error, msg_r, userData_r ); }
1142 
1144  static bool important( const std::string & msg_r, const UserData & userData_r = UserData() )
1145  { return instance()->message( MsgType::important, msg_r, userData_r ); }
1146 
1148  static bool data( const std::string & msg_r, const UserData & userData_r = UserData() )
1149  { return instance()->message( MsgType::data, msg_r, userData_r ); }
1151  };
1152 
1158  {
1160 
1161  bool debug( const std::string & msg_r ) { return JobReport::debug( msg_r, *this ); }
1162  bool info( const std::string & msg_r ) { return JobReport::info( msg_r, *this ); }
1163  bool warning( const std::string & msg_r ) { return JobReport::warning( msg_r, *this ); }
1164  bool error( const std::string & msg_r ) { return JobReport::error( msg_r, *this ); }
1165  bool important( const std::string & msg_r ) { return JobReport::important( msg_r, *this ); }
1166  bool data( const std::string & msg_r ) { return JobReport::data( msg_r, *this ); }
1167  };
1168 
1170 } // namespace zypp
1172 
1173 #endif // ZYPP_ZYPPCALLBACKS_H
bool operator()(const ProgressData &progress)
Definition: ZYppCallbacks.h:74
static const ContentType repoRefreshMirrorlist
static const UserData::ContentType contentRpmout ZYPP_API
"zypp-rpm/installpkgsa": Additional rpm output (sent immediately).
TraitsType::constPtrType constPtr
Definition: Resolvable.h:59
virtual void start(Resolvable::constPtr, const Url &)
TraitsType::constPtrType constPtr
Definition: Package.h:39
virtual bool progress(int, const Url &, double dbps_avg=-1, double dbps_current=-1)
Download progress.
Generic report for sending messages.
ProgressData::ReceiverFnc _fnc
Definition: ZYppCallbacks.h:93
virtual void fileStart(const Pathname &localfile, const UserData &userData=UserData())
File just started to download.
static const UserData::ContentType contentRpmout ZYPP_API
"zypp-rpm/scriptsa": Additional rpm output (sent immediately).
static bool error(const std::string &msg_r, const UserData &userData_r=UserData())
send error text
virtual void start(Resolvable::constPtr, const UserData &=UserData())
JobReport convenience sending this instance of UserData with each message.
virtual Action problem(Resolvable::constPtr, Error, const std::string &)
virtual void start(const ProgressData &)
Definition: ZYppCallbacks.h:42
virtual Action problem(const Url &, Error, const std::string &)
bool data(const std::string &msg_r)
virtual void pkgGpgCheck(const UserData &userData_r=UserData())
Detail information about the result of a performed pkgGpgCheck.
base::EnumClass< EMsgTypeDef > MsgType
&#39;enum class MsgType&#39;
virtual bool progress(int, Resolvable::constPtr)
bool warning(const std::string &msg_r)
virtual void start(const zypp::Url &)
#define ZYPP_DEPRECATED
The ZYPP_DEPRECATED macro can be used to trigger compile-time warnings with gcc >= 3...
Definition: Globals.h:117
virtual Action problem(Resolvable::constPtr, Error, const std::string &, RpmLevel)
virtual void finish(Resolvable::constPtr, Error, const std::string &)
virtual void finish(const zypp::Url &, Error, const std::string &)
virtual void finish(const Url &, Error, const std::string &)
virtual void finish(Pathname, Error, const std::string &)
Store and operate with byte count.
Definition: ByteCount.h:31
virtual bool start(const ProgressData &progress_r)
callback::UserData UserData
typsafe map of userdata
virtual bool start(const UserData &=UserData())
Called once, synchronously, before the irreversible transaction begins.
function< bool(const ProgressData &)> ReceiverFnc
Most simple version of progress reporting The percentage in most cases.
Definition: progressdata.h:140
virtual void start(Resolvable::constPtr, const UserData &=UserData())
static const UserData::ContentType contentRpmout ZYPP_API
"zypp-rpm/removepkgsa": Additional rpm output (sent immediately).
bool important(const std::string &msg_r)
virtual void start(Resolvable::constPtr)
virtual Action problem(Repository, Error, const std::string &)
virtual void finish(const ProgressData &)
Definition: ZYppCallbacks.h:54
virtual bool progress(const ProgressData &)
virtual void start(const std::string &, const UserData &=UserData())
virtual void end(const UserData &=UserData())
Called when all target state has been written.
bool finalReport() const
Definition: progressdata.h:336
virtual void finish()
Report success.
Error
result of cleaning
virtual void progress(int, Resolvable::constPtr, const UserData &=UserData())
What is known about a repository.
Definition: RepoInfo.h:71
static bool warning(const std::string &msg_r, const UserData &userData_r=UserData())
send warning text
virtual void finish(Resolvable::constPtr, Error, const std::string &)
bool debug(const std::string &msg_r)
virtual void fileDone(const Pathname &localfile, Error error, const UserData &userData=UserData())
File finished to download, Error indicated if it was successful for not.
delete conflicted lock
Error
result of merging
virtual bool result(const ProgressData &progress_r, const sat::Queue &noFilelist_r, const sat::FileConflicts &conflicts_r)
Indicate execution of a patch script.
virtual void progress(int, const UserData &=UserData())
Fired exactly once per TargetImpl::commit call, marking the point at which the actual RPM transaction...
static const UserData::ContentType contentLogline ZYPP_API
"zypp-rpm/logline" report a line suitable to be written to the screen.
virtual void start(Pathname)
virtual void successProbe(const Url &, const std::string &)
Libsolv queue representing file conflicts.
Definition: FileConflicts.h:30
loglevel
Rendering hint for log-lines to show.
Action
action performed by cleaning api to specific lock
virtual bool message(MsgType type_r, const std::string &msg_r, const UserData &userData_r) const
Send a ready to show message text.
virtual void start(Resolvable::constPtr)
bool info(const std::string &msg_r)
zypp::callback::UserData UserData
Definition: userrequest.h:18
Check for package file conflicts in commit (after download)
virtual bool progress(int, Pathname)
virtual void finish(Result res, const UserData &userData=UserData())
virtual void startDeltaDownload(const Pathname &, const ByteCount &)
static const UserData::ContentType contentRpmout ZYPP_API
"zypp-rpm/transactionsa": Additional rpm output (sent immediately).
virtual void start(const Url &, Pathname)
virtual Action problem(const Url &, Error, const std::string &)
virtual void finish(Error)
cleaning is done
ProgressReportAdaptor(const ProgressData::ReceiverFnc &fnc, callback::SendReport< ProgressReport > &report)
Definition: ZYppCallbacks.h:67
message type (use like &#39;enum class MsgType&#39;)
static const UserData::ContentType contentRpmout ZYPP_API
"rpmout/removepkg": Additional rpm output (sent immediately).
virtual bool progress(const ProgressData &progress_r, const sat::Queue &noFilelist_r)
const Arch Arch_empty ZYPP_API
relates: Arch This is an empty Arch represented by an empty string.
Definition: Arch.h:173
virtual Action problem(Pathname, Error, const std::string &)
virtual void finish(const Url &, Error, const std::string &)
virtual Action problem(const zypp::Url &, Error, const std::string &)
virtual Action problem(Resolvable::constPtr, Error, const std::string &)
virtual bool progress(int, Resolvable::constPtr)
Maintain [min,max] and counter (value) for progress counting.
Definition: progressdata.h:131
virtual bool progress()
merging still live
Request to display the pre commit message of a patch.
virtual Action problem(const std::string &)
Report error.
locks lock same item in pool but its parameters are different
static bool important(const std::string &msg_r, const UserData &userData_r=UserData())
send important message text
TraitsType::constPtrType constPtr
Definition: Patch.h:43
ProgressReportAdaptor(callback::SendReport< ProgressReport > &report)
Definition: ZYppCallbacks.h:62
virtual void progress(int, Resolvable::constPtr, const UserData &=UserData())
virtual void problemDeltaApply(const std::string &)
this callback handles merging old locks with newly added or removed
static bool data(const std::string &msg_r, const UserData &userData_r=UserData())
send data message
Class for handling media authentication data.
Definition: authdata.h:30
static bool debug(const std::string &msg_r, const UserData &userData_r=UserData())
send debug message text
virtual void start(const UserData &userData=UserData())
virtual void finish(Resolvable::constPtr, Error, const std::string &, RpmLevel)
virtual void problemDeltaDownload(const std::string &)
virtual bool prompt(const Url &, const std::string &, AuthData &)
Prompt for authentication data.
Temporarily disable MediaChangeReport Sometimes helpful to suppress interactive messages connected to...
UserData()
Default ctor.
Definition: UserData.h:55
virtual void start(const std::string &, const std::string &, Resolvable::constPtr, const UserData &=UserData())
virtual void failedProbe(const Url &, const std::string &)
Libsolv Id queue wrapper.
Definition: Queue.h:35
virtual void start(const ProgressData &, const RepoInfo)
static const UserData::ContentType contentRpmout ZYPP_API
"rpmout/installpkg": Additional rpm output (sent immediately).
virtual bool progress(int)
progress of cleaning specifies in percents
virtual void finish(Error, const UserData &=UserData())
Action
action for old lock which is in conflict
Meta-data query API.
Definition: PoolQuery.h:90
virtual void start(const Url &)
virtual bool progress(int)
virtual void finish(Resolvable::constPtr, Error, const UserData &=UserData())
callback::SendReport< ProgressReport > & _report
Definition: ZYppCallbacks.h:94
bool error(const std::string &msg_r)
virtual void start(const Package::constPtr &, const Pathname &)
Start executing the script provided by package.
zypp::ContentType ContentType
Definition: userrequest.h:19
Report active throughout the whole rpm transaction.
Typesafe passing of user data via callbacks.
Definition: UserData.h:39
abort and return error
virtual void finish(Repository, const std::string &, Error, const std::string &)
virtual void progress(int, const UserData &=UserData())
virtual Action execute(const PoolQuery &)
When find empty lock ask what to do with it.
virtual Action requestMedia(Url &, unsigned, const std::string &, Error, const std::string &, const std::vector< std::string > &, unsigned int &)
virtual void progress(int, Resolvable::constPtr, const UserData &=UserData())
virtual void startDeltaApply(const Pathname &)
virtual bool progress(Notify, const std::string &=std::string())
Progress provides the script output.
static bool info(const std::string &msg_r, const UserData &userData_r=UserData())
send message text
virtual bool progress(const ProgressData &)
Definition: ZYppCallbacks.h:45
virtual bool progress(int, Resolvable::constPtr)
ConflictState
type of conflict of old and new lock
shared_ptr< callback::TempConnect< media::MediaChangeReport > > _guard
Callback for cleaning locks which doesn&#39;t lock anything in pool.
virtual bool progress(int value, const UserData &userData=UserData())
Overall Download progress.
virtual void finish(Resolvable::constPtr, Error, const UserData &=UserData())
virtual void finish(Resolvable::constPtr, Error, const UserData &=UserData())
Easy-to use interface to the ZYPP dependency resolver.
Definition: CodePitfalls.doc:1
virtual void step(const UserData &=UserData())
virtual void finish(Error, const UserData &=UserData())
static const UserData::ContentType contentRpmout ZYPP_API
"zypp-rpm/cleanupkgsa": Additional rpm output (sent immediately).
static const char *const loglevelPrefix(loglevel level_r)
Suggested prefix for log-lines to show.
Url manipulation class.
Definition: Url.h:92
virtual void start()
cleaning is started
virtual bool progress(const Url &, int)
virtual void infoInCache(Resolvable::constPtr res_r, const Pathname &localfile_r)
Hint that package is available in the local cache (no download needed).
virtual void start(const std::string &, const UserData &=UserData())
Mime type like &#39;type/subtype&#39; classification of content.
Definition: ContentType.h:29
virtual bool show(Patch::constPtr &)
Display patch->message().
virtual Action conflict(const PoolQuery &, ConflictState)
When user unlock something which is locked by non-identical query.
virtual void finish(Error)