libzypp  15.21.4
MediaSetAccess.cc
Go to the documentation of this file.
1 /*---------------------------------------------------------------------\
2 | ____ _ __ __ ___ |
3 | |__ / \ / / . \ . \ |
4 | / / \ V /| _/ _/ |
5 | / /__ | | | | | | |
6 | /_____||_| |_| |_| |
7 | |
8 \---------------------------------------------------------------------*/
9 
10 #include <iostream>
11 #include <fstream>
12 
13 #include "zypp/base/LogTools.h"
14 #include "zypp/base/Regex.h"
16 #include "zypp/ZYppCallbacks.h"
17 #include "zypp/MediaSetAccess.h"
18 #include "zypp/PathInfo.h"
19 //#include "zypp/source/MediaSetAccessReportReceivers.h"
20 
21 using namespace std;
22 
24 namespace zypp
25 {
26 
27 IMPL_PTR_TYPE(MediaSetAccess);
28 
30 
31  MediaSetAccess::MediaSetAccess(const Url &url,
32  const Pathname & prefered_attach_point)
33  : _url(url)
34  , _prefAttachPoint(prefered_attach_point)
35  {}
36 
37  MediaSetAccess::MediaSetAccess(const std::string & label_r,
38  const Url &url,
39  const Pathname & prefered_attach_point)
40  : _url(url)
41  , _prefAttachPoint(prefered_attach_point)
42  , _label( label_r )
43  {}
44 
46  {
47  try
48  {
49  release();
50  }
51  catch(...) {} // don't let exception escape a dtor.
52  }
53 
54 
56  {
57  if (_medias.find(media_nr) != _medias.end())
58  {
59  // the media already exists, set theverifier
60  media::MediaAccessId id = _medias[media_nr];
61  media::MediaManager media_mgr;
62  media_mgr.addVerifier( id, verifier );
63  // remove any saved verifier for this media
64  _verifiers.erase(media_nr);
65  }
66  else
67  {
68  // save the verifier in the map, and set it when
69  // the media number is first attached
70  _verifiers[media_nr] = verifier;
71  }
72  }
73 
74  void MediaSetAccess::releaseFile( const OnMediaLocation & on_media_file )
75  {
76  releaseFile( on_media_file.filename(), on_media_file.medianr() );
77  }
78 
79  void MediaSetAccess::releaseFile( const Pathname & file, unsigned media_nr)
80  {
81  media::MediaManager media_mgr;
83 
84  media = getMediaAccessId( media_nr);
85  DBG << "Going to release file " << file
86  << " from media number " << media_nr << endl;
87 
88  if ( ! media_mgr.isAttached(media) )
89  return; //disattached media is free
90 
91  media_mgr.releaseFile (media, file);
92  }
93 
94  void MediaSetAccess::dirInfo( filesystem::DirContent &retlist, const Pathname &dirname,
95  bool dots, unsigned media_nr )
96  {
97  media::MediaManager media_mgr;
99  media = getMediaAccessId(media_nr);
100 
101  // try to attach the media
102  if ( ! media_mgr.isAttached(media) )
103  media_mgr.attach(media);
104 
105  media_mgr.dirInfo(media, retlist, dirname, dots);
106  }
107 
109  {
110  Pathname result;
111  void operator()( media::MediaAccessId media, const Pathname &file )
112  {
113  media::MediaManager media_mgr;
114  media_mgr.provideFile(media, file);
115  result = media_mgr.localPath(media, file);
116  }
117  };
118 
120  {
121  Pathname result;
122  void operator()( media::MediaAccessId media, const Pathname &file )
123  {
124  media::MediaManager media_mgr;
125  media_mgr.provideDirTree(media, file);
126  result = media_mgr.localPath(media, file);
127  }
128  };
129 
131  {
132  Pathname result;
133  void operator()( media::MediaAccessId media, const Pathname &file )
134  {
135  media::MediaManager media_mgr;
136  media_mgr.provideDir(media, file);
137  result = media_mgr.localPath(media, file);
138  }
139  };
140 
142  {
143  bool result;
145  : result(false)
146  {}
147 
148  void operator()( media::MediaAccessId media, const Pathname &file )
149  {
150  media::MediaManager media_mgr;
151  result = media_mgr.doesFileExist(media, file);
152  }
153  };
154 
155 
156 
157  Pathname MediaSetAccess::provideFile( const OnMediaLocation & resource, ProvideFileOptions options, const Pathname &deltafile )
158  {
160  provide( boost::ref(op), resource, options, deltafile );
161  return op.result;
162  }
163 
164  Pathname MediaSetAccess::provideFile(const Pathname & file, unsigned media_nr, ProvideFileOptions options )
165  {
166  OnMediaLocation resource;
168  resource.setLocation(file, media_nr);
169  provide( boost::ref(op), resource, options, Pathname() );
170  return op.result;
171  }
172 
173  bool MediaSetAccess::doesFileExist(const Pathname & file, unsigned media_nr )
174  {
176  OnMediaLocation resource;
177  resource.setLocation(file, media_nr);
178  provide( boost::ref(op), resource, PROVIDE_DEFAULT, Pathname());
179  return op.result;
180  }
181 
183  const OnMediaLocation &resource,
184  ProvideFileOptions options,
185  const Pathname &deltafile )
186  {
187  Pathname file(resource.filename());
188  unsigned media_nr(resource.medianr());
189 
191  media::MediaManager media_mgr;
192 
193  media::MediaAccessId media;
194 
195  do
196  {
197  // get the mediaId, but don't try to attach it here
198  media = getMediaAccessId( media_nr);
199  bool deltafileset = false;
200 
201  try
202  {
203  DBG << "Going to try to provide " << (resource.optional() ? "optional" : "") << " file " << file
204  << " from media number " << media_nr << endl;
205  // try to attach the media
206  if ( ! media_mgr.isAttached(media) )
207  media_mgr.attach(media);
208  media_mgr.setDeltafile(media, deltafile);
209  deltafileset = true;
210  op(media, file);
211  media_mgr.setDeltafile(media, Pathname());
212  break;
213  }
214  catch ( media::MediaException & excp )
215  {
216  ZYPP_CAUGHT(excp);
217  if (deltafileset)
218  media_mgr.setDeltafile(media, Pathname());
220  unsigned int devindex = 0;
221  vector<string> devices;
222  media_mgr.getDetectedDevices(media, devices, devindex);
223 
224  do
225  {
226  if (user != media::MediaChangeReport::EJECT) // no use in calling this again
227  {
228  DBG << "Media couldn't provide file " << file << " , releasing." << endl;
229  try
230  {
231  media_mgr.release(media);
232  }
233  catch (const Exception & excpt_r)
234  {
235  ZYPP_CAUGHT(excpt_r);
236  MIL << "Failed to release media " << media << endl;
237  }
238  }
239 
240  // set up the reason
242 
243  if( typeid(excp) == typeid( media::MediaFileNotFoundException ) ||
244  typeid(excp) == typeid( media::MediaNotAFileException ) )
245  {
247  }
248  else if( typeid(excp) == typeid( media::MediaNotDesiredException) ||
249  typeid(excp) == typeid( media::MediaNotAttachedException) )
250  {
252  }
253  else if( typeid(excp) == typeid( media::MediaTimeoutException) ||
254  typeid(excp) == typeid( media::MediaTemporaryProblemException))
255  {
257  }
258 
259  // Propagate the original error if _no_ callback receiver is connected, or
260  // non_interactive mode (for optional files) is used (except for wrong media).
262  || (( options & PROVIDE_NON_INTERACTIVE ) && reason != media::MediaChangeReport::WRONG ) )
263  {
264  MIL << "Can't provide file. Non-Interactive mode." << endl;
265  ZYPP_RETHROW(excp);
266  }
267  else
268  {
269  // release all media before requesting another (#336881)
270  media_mgr.releaseAll();
271 
272  user = report->requestMedia (
273  _url,
274  media_nr,
275  _label,
276  reason,
277  excp.asUserString(),
278  devices,
279  devindex
280  );
281  }
282 
283  MIL << "ProvideFile exception caught, callback answer: " << user << endl;
284 
285  if( user == media::MediaChangeReport::ABORT )
286  {
287  DBG << "Aborting" << endl;
288  AbortRequestException aexcp("Aborting requested by user");
289  aexcp.remember(excp);
290  ZYPP_THROW(aexcp);
291  }
292  else if ( user == media::MediaChangeReport::IGNORE )
293  {
294  DBG << "Skipping" << endl;
295  SkipRequestException nexcp("User-requested skipping of a file");
296  nexcp.remember(excp);
297  ZYPP_THROW(nexcp);
298  }
299  else if ( user == media::MediaChangeReport::EJECT )
300  {
301  DBG << "Eject: try to release" << endl;
302  try
303  {
304  media_mgr.releaseAll();
305  media_mgr.release (media, devindex < devices.size() ? devices[devindex] : "");
306  }
307  catch ( const Exception & e)
308  {
309  ZYPP_CAUGHT(e);
310  }
311  }
312  else if ( user == media::MediaChangeReport::RETRY ||
314  {
315  // retry
316  DBG << "Going to try again" << endl;
317  // invalidate current media access id
318  media_mgr.close(media);
319  _medias.erase(media_nr);
320 
321  // not attaching, media set will do that for us
322  // this could generate uncaught exception (#158620)
323  break;
324  }
325  else
326  {
327  DBG << "Don't know, let's ABORT" << endl;
328  ZYPP_RETHROW ( excp );
329  }
330  } while( user == media::MediaChangeReport::EJECT );
331  }
332 
333  // retry or change URL
334  } while( true );
335  }
336 
337  Pathname MediaSetAccess::provideDir(const Pathname & dir,
338  bool recursive,
339  unsigned media_nr,
340  ProvideFileOptions options )
341  {
342  OnMediaLocation resource;
343  resource.setLocation(dir, media_nr);
344  if ( recursive )
345  {
347  provide( boost::ref(op), resource, options, Pathname());
348  return op.result;
349  }
351  provide( boost::ref(op), resource, options, Pathname());
352  return op.result;
353  }
354 
356  {
357  media::MediaManager media_mgr;
358 
359  if (_medias.find(medianr) != _medias.end())
360  {
361  media::MediaAccessId id = _medias[medianr];
362  return id;
363  }
364  Url url;
365  url = rewriteUrl (_url, medianr);
366  media::MediaAccessId id = media_mgr.open(url, _prefAttachPoint);
367  _medias[medianr] = id;
368 
369  try
370  {
371  if (_verifiers.find(medianr) != _verifiers.end())
372  {
373  // a verifier is set for this media
374  // FIXME check the case where the verifier exists
375  // but we have no access id for the media
376  media::MediaAccessId id = _medias[medianr];
377  media::MediaManager media_mgr;
378  media_mgr.delVerifier(id);
379  media_mgr.addVerifier( id, _verifiers[medianr] );
380  // remove any saved verifier for this media
381  _verifiers.erase(medianr);
382  }
383  }
384  catch ( const Exception &e )
385  {
386  ZYPP_CAUGHT(e);
387  WAR << "Verifier not found" << endl;
388  }
389 
390  return id;
391  }
392 
393 
394  Url MediaSetAccess::rewriteUrl (const Url & url_r, const media::MediaNr medianr)
395  {
396  std::string scheme = url_r.getScheme();
397  if (scheme == "cd" || scheme == "dvd")
398  return url_r;
399 
400  DBG << "Rewriting url " << url_r << endl;
401 
402  if( scheme == "iso")
403  {
404  // TODO the iso parameter will not be required in the future, this
405  // code has to be adapted together with the MediaISO change.
406  // maybe some MediaISOURL interface should be used.
407  std::string isofile = url_r.getQueryParam("iso");
408  str::regex e("^(.*)(cd|dvd|media)[0-9]+\\.iso$", str::regex::icase);
409 
410  str::smatch what;
411  if(str::regex_match(isofile, what, e))
412  {
413  Url url( url_r);
414  isofile = what[1] + what[2] + str::numstring(medianr) + ".iso";
415  url.setQueryParam("iso", isofile);
416  DBG << "Url rewrite result: " << url << endl;
417  return url;
418  }
419  }
420  else
421  {
422  std::string pathname = url_r.getPathName();
423  str::regex e("^(.*)(cd|dvd|media)[0-9]+(/)?$", str::regex::icase);
424  str::smatch what;
425  if(str::regex_match(pathname, what, e))
426  {
427  Url url( url_r);
428  pathname = what[1] + what[2] + str::numstring(medianr) + what[3];
429  url.setPathName(pathname);
430  DBG << "Url rewrite result: " << url << endl;
431  return url;
432  }
433  }
434  return url_r;
435  }
436 
438  {
439  DBG << "Releasing all media IDs held by this MediaSetAccess" << endl;
440  media::MediaManager manager;
441  for (MediaMap::const_iterator m = _medias.begin(); m != _medias.end(); ++m)
442  manager.release(m->second, "");
443  }
444 
445  std::ostream & MediaSetAccess::dumpOn( std::ostream & str ) const
446  {
447  str << "MediaSetAccess (URL='" << _url << "', attach_point_hint='" << _prefAttachPoint << "')";
448  return str;
449  }
450 
452 } // namespace zypp
void releaseFile(MediaAccessId accessId, const Pathname &filename) const
FIXME: see MediaAccess class.
#define MIL
Definition: Logger.h:64
void provideDir(MediaAccessId accessId, const Pathname &dirname) const
FIXME: see MediaAccess class.
void provide(ProvideOperation op, const OnMediaLocation &resource, ProvideFileOptions options, const Pathname &deltafile)
void setQueryParam(const std::string &param, const std::string &value)
Set or add value for the specified query parameter.
Definition: Url.cc:827
#define ZYPP_THROW(EXCPT)
Drops a logline and throws the Exception.
Definition: Exception.h:321
Describes a path on a certain media amongs as the information required to download it...
Regular expression.
Definition: Regex.h:86
MediaMap _medias
Mapping between media number and Media Access ID.
Url _url
Media or media set URL.
std::string getPathName(EEncoding eflag=zypp::url::E_DECODED) const
Returns the path name from the URL.
Definition: Url.cc:598
Pathname provideDir(const Pathname &dir, bool recursive, unsigned media_nr=1, ProvideFileOptions options=PROVIDE_DEFAULT)
Provides direcotry dir from media number media_nr.
unsigned medianr() const
media number where the resource is located.
void setDeltafile(MediaAccessId accessId, const Pathname &filename) const
IO error which can happen on worse connection like timeout exceed.
bool doesFileExist(const Pathname &file, unsigned media_nr=1)
Checks if a file exists on the specified media, with user callbacks.
Pathname _prefAttachPoint
Prefered mount point.
void release()
Release all attached media of this set.
static Url rewriteUrl(const Url &url_r, const media::MediaNr medianr)
Replaces media number in specified url with given medianr.
void dirInfo(MediaAccessId accessId, std::list< std::string > &retlist, const Pathname &dirname, bool dots=true) const
FIXME: see MediaAccess class.
virtual std::ostream & dumpOn(std::ostream &str) const
Overload to realize std::ostream & operator<<.
void provideFile(MediaAccessId accessId, const Pathname &filename) const
Provide provide file denoted by relative path below of the 'attach point' of the specified media and ...
unsigned int MediaAccessId
Media manager access Id type.
Definition: MediaSource.h:29
void operator()(media::MediaAccessId media, const Pathname &file)
void releaseFile(const OnMediaLocation &resource)
Release file from media.
void release(MediaAccessId accessId, const std::string &ejectDev="")
Release the attached media and optionally eject.
bool doesFileExist(MediaAccessId accessId, const Pathname &filename) const
FIXME: see MediaAccess class.
#define ZYPP_RETHROW(EXCPT)
Drops a logline and rethrows, updating the CodeLocation.
Definition: Exception.h:329
void setPathName(const std::string &path, EEncoding eflag=zypp::url::E_DECODED)
Set the path name.
Definition: Url.cc:758
Do not differentiate case.
Definition: Regex.h:91
Just inherits Exception to separate media exceptions.
void dirInfo(filesystem::DirContent &retlist, const Pathname &dirname, bool dots=true, unsigned media_nr=1)
Fills retlist with directory information.
Pathname localPath(MediaAccessId accessId, const Pathname &pathname) const
Shortcut for 'localRoot() + pathname', but returns an empty pathname if media is not attached...
void getDetectedDevices(MediaAccessId accessId, std::vector< std::string > &devices, unsigned int &index) const
Fill in a vector of detected ejectable devices and the index of the currently attached device within ...
#define WAR
Definition: Logger.h:65
std::list< DirEntry > DirContent
Returned by readdir.
Definition: PathInfo.h:547
void addVerifier(MediaAccessId accessId, const MediaVerifierRef &verifier)
Add verifier implementation for the specified media id.
zypp::Url url
Definition: MediaCurl.cc:192
void operator()(media::MediaAccessId media, const Pathname &file)
std::string getQueryParam(const std::string &param, EEncoding eflag=zypp::url::E_DECODED) const
Return the value for the specified query parameter.
Definition: Url.cc:654
std::string numstring(char n, int w=0)
Definition: String.h:304
void attach(MediaAccessId accessId)
Attach the media using the concrete handler (checks all devices).
function< void(media::MediaAccessId, const Pathname &)> ProvideOperation
#define ZYPP_CAUGHT(EXCPT)
Drops a logline telling the Exception was caught (in order to handle it).
Definition: Exception.h:325
Regular expression match result.
Definition: Regex.h:145
Manages access to the 'physical' media, e.g CDROM drives, Disk volumes, directory trees...
Definition: MediaManager.h:473
Base class for Exception.
Definition: Exception.h:143
void operator()(media::MediaAccessId media, const Pathname &file)
void setVerifier(unsigned media_nr, media::MediaVerifierRef verifier)
Sets a MediaVerifier verifier for given media number.
callback::SendReport< DownloadProgressReport > * report
Definition: MediaCurl.cc:177
const Pathname & filename() const
The path to the resource relatve to the url and path.
MediaVerifierRef verifier
Wrapper for const correct access via Smart pointer types.
Definition: PtrTypes.h:285
media::MediaAccessId getMediaAccessId(media::MediaNr medianr)
bool regex_match(const std::string &s, smatch &matches, const regex &regex)
regex ZYPP_STR_REGEX regex ZYPP_STR_REGEX
Definition: Regex.h:70
void provideDirTree(MediaAccessId accessId, const Pathname &dirname) const
FIXME: see MediaAccess class.
const bool optional() const
whether this is an optional resource.
bool isAttached(MediaAccessId accessId) const
Check if media is attached or not.
void operator()(media::MediaAccessId media, const Pathname &file)
std::string getScheme() const
Returns the scheme name of the URL.
Definition: Url.cc:527
void releaseAll()
Release all attached media.
Pathname provideFile(const OnMediaLocation &resource, ProvideFileOptions options=PROVIDE_DEFAULT, const Pathname &deltafile=Pathname())
Provides a file from a media location.
MediaSetAccess(const Url &url, const Pathname &prefered_attach_point="")
Creates a callback enabled media access for specified url.
std::string asUserString() const
Translated error message as string suitable for the user.
Definition: Exception.cc:66
MediaAccessId open(const Url &url, const Pathname &preferred_attach_point="")
Opens the media access for specified with the url.
VerifierMap _verifiers
Mapping between media number and corespondent verifier.
Url manipulation class.
Definition: Url.h:87
void delVerifier(MediaAccessId accessId)
Remove verifier for specified media id.
OnMediaLocation & setLocation(const Pathname &val_r, unsigned mediaNumber_r=1)
Set filename and media number (defaults to 1).
#define IMPL_PTR_TYPE(NAME)
unsigned int MediaNr
Definition: MediaManager.h:40
void close(MediaAccessId accessId)
Close the media access with specified id.
#define DBG
Definition: Logger.h:63
The user is not asked anything, and the error exception is just propagated.