libzypp  17.3.1
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/TmpPath.h"
20 //#include "zypp/source/MediaSetAccessReportReceivers.h"
21 
22 using namespace std;
23 
25 namespace zypp
26 {
27 
28 IMPL_PTR_TYPE(MediaSetAccess);
29 
31 
32  MediaSetAccess::MediaSetAccess(const Url &url,
33  const Pathname & prefered_attach_point)
34  : _url(url)
35  , _prefAttachPoint(prefered_attach_point)
36  {}
37 
38  MediaSetAccess::MediaSetAccess(const std::string & label_r,
39  const Url &url,
40  const Pathname & prefered_attach_point)
41  : _url(url)
42  , _prefAttachPoint(prefered_attach_point)
43  , _label( label_r )
44  {}
45 
47  {
48  try
49  {
50  release();
51  }
52  catch(...) {} // don't let exception escape a dtor.
53  }
54 
55 
57  {
58  if (_medias.find(media_nr) != _medias.end())
59  {
60  // the media already exists, set theverifier
61  media::MediaAccessId id = _medias[media_nr];
62  media::MediaManager media_mgr;
63  media_mgr.addVerifier( id, verifier );
64  // remove any saved verifier for this media
65  _verifiers.erase(media_nr);
66  }
67  else
68  {
69  // save the verifier in the map, and set it when
70  // the media number is first attached
71  _verifiers[media_nr] = verifier;
72  }
73  }
74 
75  void MediaSetAccess::releaseFile( const OnMediaLocation & on_media_file )
76  {
77  releaseFile( on_media_file.filename(), on_media_file.medianr() );
78  }
79 
80  void MediaSetAccess::releaseFile( const Pathname & file, unsigned media_nr)
81  {
82  media::MediaManager media_mgr;
84 
85  media = getMediaAccessId( media_nr);
86  DBG << "Going to release file " << file
87  << " from media number " << media_nr << endl;
88 
89  if ( ! media_mgr.isAttached(media) )
90  return; //disattached media is free
91 
92  media_mgr.releaseFile (media, file);
93  }
94 
96  bool dots, unsigned media_nr )
97  {
98  media::MediaManager media_mgr;
100  media = getMediaAccessId(media_nr);
101 
102  // try to attach the media
103  if ( ! media_mgr.isAttached(media) )
104  media_mgr.attach(media);
105 
106  media_mgr.dirInfo(media, retlist, dirname, dots);
107  }
108 
110  {
112  void operator()( media::MediaAccessId media, const Pathname &file )
113  {
114  media::MediaManager media_mgr;
115  media_mgr.provideFile(media, file);
116  result = media_mgr.localPath(media, file);
117  }
118  };
119 
121  {
123  void operator()( media::MediaAccessId media, const Pathname &file )
124  {
125  media::MediaManager media_mgr;
126  media_mgr.provideDirTree(media, file);
127  result = media_mgr.localPath(media, file);
128  }
129  };
130 
132  {
134  void operator()( media::MediaAccessId media, const Pathname &file )
135  {
136  media::MediaManager media_mgr;
137  media_mgr.provideDir(media, file);
138  result = media_mgr.localPath(media, file);
139  }
140  };
141 
143  {
144  bool result;
146  : result(false)
147  {}
148 
149  void operator()( media::MediaAccessId media, const Pathname &file )
150  {
151  media::MediaManager media_mgr;
152  result = media_mgr.doesFileExist(media, file);
153  }
154  };
155 
156 
157 
158  Pathname MediaSetAccess::provideFile( const OnMediaLocation & resource, ProvideFileOptions options, const Pathname &deltafile )
159  {
161  provide( boost::ref(op), resource, options, deltafile );
162  return op.result;
163  }
164 
165  Pathname MediaSetAccess::provideFile(const Pathname & file, unsigned media_nr, ProvideFileOptions options )
166  {
167  OnMediaLocation resource;
169  resource.setLocation(file, media_nr);
170  provide( boost::ref(op), resource, options, Pathname() );
171  return op.result;
172  }
173 
174  ManagedFile MediaSetAccess::provideFileFromUrl(const Url &file_url, ProvideFileOptions options)
175  {
176  Url url(file_url);
177  Pathname path(url.getPathName());
178  url.setPathName ("/");
179  MediaSetAccess access(url);
180 
182 
183  Pathname file = access.provideFile(path, 1, options);
184 
185  //prevent the file from being deleted when MediaSetAccess gets out of scope
186  if ( filesystem::hardlinkCopy(file, tmpFile) != 0 )
187  ZYPP_THROW(Exception("Can't copy file from " + file.asString() + " to " + tmpFile->asString() ));
188 
189  return tmpFile;
190  }
191 
192  Pathname MediaSetAccess::provideOptionalFile( const Pathname & file, unsigned media_nr )
193  {
194  try
195  {
196  if ( doesFileExist( file, media_nr ) )
197  return provideFile( file, media_nr, PROVIDE_NON_INTERACTIVE );
198  }
199  catch ( const media::MediaFileNotFoundException & excpt_r )
200  { ZYPP_CAUGHT( excpt_r ); }
201  catch ( const media::MediaNotAFileException & excpt_r )
202  { ZYPP_CAUGHT( excpt_r ); }
203  return Pathname();
204  }
205 
206  bool MediaSetAccess::doesFileExist(const Pathname & file, unsigned media_nr )
207  {
209  OnMediaLocation resource;
210  resource.setLocation(file, media_nr);
211  provide( boost::ref(op), resource, PROVIDE_DEFAULT, Pathname());
212  return op.result;
213  }
214 
216  const OnMediaLocation &resource,
217  ProvideFileOptions options,
218  const Pathname &deltafile )
219  {
220  Pathname file(resource.filename());
221  unsigned media_nr(resource.medianr());
222 
224  media::MediaManager media_mgr;
225 
226  media::MediaAccessId media;
227 
228  do
229  {
230  // get the mediaId, but don't try to attach it here
231  media = getMediaAccessId( media_nr);
232  bool deltafileset = false;
233 
234  try
235  {
236  DBG << "Going to try to provide " << (resource.optional() ? "optional" : "") << " file " << file
237  << " from media number " << media_nr << endl;
238  // try to attach the media
239  if ( ! media_mgr.isAttached(media) )
240  media_mgr.attach(media);
241  media_mgr.setDeltafile(media, deltafile);
242  deltafileset = true;
243  op(media, file);
244  media_mgr.setDeltafile(media, Pathname());
245  break;
246  }
247  catch ( media::MediaException & excp )
248  {
249  ZYPP_CAUGHT(excp);
250  if (deltafileset)
251  media_mgr.setDeltafile(media, Pathname());
253  unsigned int devindex = 0;
254  vector<string> devices;
255  media_mgr.getDetectedDevices(media, devices, devindex);
256 
257  do
258  {
259  if (user != media::MediaChangeReport::EJECT) // no use in calling this again
260  {
261  DBG << "Media couldn't provide file " << file << " , releasing." << endl;
262  try
263  {
264  media_mgr.release(media);
265  }
266  catch (const Exception & excpt_r)
267  {
268  ZYPP_CAUGHT(excpt_r);
269  MIL << "Failed to release media " << media << endl;
270  }
271  }
272 
273  // set up the reason
275 
276  if( typeid(excp) == typeid( media::MediaFileNotFoundException ) ||
277  typeid(excp) == typeid( media::MediaNotAFileException ) )
278  {
280  }
281  else if( typeid(excp) == typeid( media::MediaNotDesiredException) ||
282  typeid(excp) == typeid( media::MediaNotAttachedException) )
283  {
285  }
286  else if( typeid(excp) == typeid( media::MediaTimeoutException) ||
287  typeid(excp) == typeid( media::MediaTemporaryProblemException))
288  {
290  }
291 
292  // Propagate the original error if _no_ callback receiver is connected, or
293  // non_interactive mode (for optional files) is used (except for wrong media).
295  || (( options & PROVIDE_NON_INTERACTIVE ) && reason != media::MediaChangeReport::WRONG ) )
296  {
297  MIL << "Can't provide file. Non-Interactive mode." << endl;
298  ZYPP_RETHROW(excp);
299  }
300  else
301  {
302  // release all media before requesting another (#336881)
303  media_mgr.releaseAll();
304 
305  user = report->requestMedia (
306  _url,
307  media_nr,
308  _label,
309  reason,
310  excp.asUserHistory(),
311  devices,
312  devindex
313  );
314  }
315 
316  MIL << "ProvideFile exception caught, callback answer: " << user << endl;
317 
318  if( user == media::MediaChangeReport::ABORT )
319  {
320  DBG << "Aborting" << endl;
321  AbortRequestException aexcp("Aborting requested by user");
322  aexcp.remember(excp);
323  ZYPP_THROW(aexcp);
324  }
325  else if ( user == media::MediaChangeReport::IGNORE )
326  {
327  DBG << "Skipping" << endl;
328  SkipRequestException nexcp("User-requested skipping of a file");
329  nexcp.remember(excp);
330  ZYPP_THROW(nexcp);
331  }
332  else if ( user == media::MediaChangeReport::EJECT )
333  {
334  DBG << "Eject: try to release" << endl;
335  try
336  {
337  media_mgr.releaseAll();
338  media_mgr.release (media, devindex < devices.size() ? devices[devindex] : "");
339  }
340  catch ( const Exception & e)
341  {
342  ZYPP_CAUGHT(e);
343  }
344  }
345  else if ( user == media::MediaChangeReport::RETRY ||
347  {
348  // retry
349  DBG << "Going to try again" << endl;
350  // invalidate current media access id
351  media_mgr.close(media);
352  _medias.erase(media_nr);
353 
354  // not attaching, media set will do that for us
355  // this could generate uncaught exception (#158620)
356  break;
357  }
358  else
359  {
360  DBG << "Don't know, let's ABORT" << endl;
361  ZYPP_RETHROW ( excp );
362  }
363  } while( user == media::MediaChangeReport::EJECT );
364  }
365 
366  // retry or change URL
367  } while( true );
368  }
369 
371  bool recursive,
372  unsigned media_nr,
373  ProvideFileOptions options )
374  {
375  OnMediaLocation resource;
376  resource.setLocation(dir, media_nr);
377  if ( recursive )
378  {
380  provide( boost::ref(op), resource, options, Pathname());
381  return op.result;
382  }
384  provide( boost::ref(op), resource, options, Pathname());
385  return op.result;
386  }
387 
389  {
390  if ( _medias.find( medianr ) != _medias.end() )
391  {
392  return _medias[medianr];
393  }
394 
395  Url url( medianr > 1 ? rewriteUrl( _url, medianr ) : _url );
396  media::MediaManager media_mgr;
397  media::MediaAccessId id = media_mgr.open( url, _prefAttachPoint );
398  _medias[medianr] = id;
399 
400  try
401  {
402  if ( _verifiers.find(medianr) != _verifiers.end() )
403  {
404  // a verifier is set for this media
405  // FIXME check the case where the verifier exists
406  // but we have no access id for the media
407  media_mgr.delVerifier( id );
408  media_mgr.addVerifier( id, _verifiers[medianr] );
409  // remove any saved verifier for this media
410  _verifiers.erase( medianr );
411  }
412  }
413  catch ( const Exception &e )
414  {
415  ZYPP_CAUGHT(e);
416  WAR << "Verifier not found" << endl;
417  }
418 
419  return id;
420  }
421 
422 
423  Url MediaSetAccess::rewriteUrl (const Url & url_r, const media::MediaNr medianr)
424  {
425  std::string scheme = url_r.getScheme();
426  if (scheme == "cd" || scheme == "dvd")
427  return url_r;
428 
429  DBG << "Rewriting url " << url_r << endl;
430 
431  if( scheme == "iso")
432  {
433  // TODO the iso parameter will not be required in the future, this
434  // code has to be adapted together with the MediaISO change.
435  // maybe some MediaISOURL interface should be used.
436  std::string isofile = url_r.getQueryParam("iso");
437  str::regex e("^(.*)(cd|dvd|media)[0-9]+\\.iso$", str::regex::icase);
438 
439  str::smatch what;
440  if(str::regex_match(isofile, what, e))
441  {
442  Url url( url_r);
443  isofile = what[1] + what[2] + str::numstring(medianr) + ".iso";
444  url.setQueryParam("iso", isofile);
445  DBG << "Url rewrite result: " << url << endl;
446  return url;
447  }
448  }
449  else
450  {
451  std::string pathname = url_r.getPathName();
452  str::regex e("^(.*)(cd|dvd|media)[0-9]+(/)?$", str::regex::icase);
453  str::smatch what;
454  if(str::regex_match(pathname, what, e))
455  {
456  Url url( url_r);
457  pathname = what[1] + what[2] + str::numstring(medianr) + what[3];
458  url.setPathName(pathname);
459  DBG << "Url rewrite result: " << url << endl;
460  return url;
461  }
462  }
463  return url_r;
464  }
465 
467  {
468  DBG << "Releasing all media IDs held by this MediaSetAccess" << endl;
469  media::MediaManager manager;
470  for (MediaMap::const_iterator m = _medias.begin(); m != _medias.end(); ++m)
471  manager.release(m->second, "");
472  }
473 
474  std::ostream & MediaSetAccess::dumpOn( std::ostream & str ) const
475  {
476  str << "MediaSetAccess (URL='" << _url << "', attach_point_hint='" << _prefAttachPoint << "')";
477  return str;
478  }
479 
481 } // namespace zypp
std::string getScheme() const
Returns the scheme name of the URL.
Definition: Url.cc:527
#define MIL
Definition: Logger.h:64
void provide(ProvideOperation op, const OnMediaLocation &resource, ProvideFileOptions options, const Pathname &deltafile)
void provideDirTree(MediaAccessId accessId, const Pathname &dirname) const
FIXME: see MediaAccess class.
void setDeltafile(MediaAccessId accessId, const Pathname &filename) const
#define ZYPP_THROW(EXCPT)
Drops a logline and throws the Exception.
Definition: Exception.h:392
Describes a path on a certain media amongs as the information required to download it...
Regular expression.
Definition: Regex.h:86
static ManagedFile provideFileFromUrl(const Url &file_url, ProvideFileOptions options=PROVIDE_DEFAULT)
Provides file from url.
bool doesFileExist(MediaAccessId accessId, const Pathname &filename) const
FIXME: see MediaAccess class.
MediaMap _medias
Mapping between media number and Media Access ID.
Url _url
Media or media set URL.
Pathname provideOptionalFile(const Pathname &file, unsigned media_nr=1)
Provides an optional file from media media_nr.
Pathname provideDir(const Pathname &dir, bool recursive, unsigned media_nr=1, ProvideFileOptions options=PROVIDE_DEFAULT)
Provides direcotry dir from media number media_nr.
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<<.
IO error which can happen on worse connection like timeout exceed.
String related utilities and Regular expression matching.
bool doesFileExist(const Pathname &file, unsigned media_nr=1)
Checks if a file exists on the specified media, with user callbacks.
Definition: Arch.h:344
Url url
Definition: MediaCurl.cc:196
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.
const bool optional() const
whether this is an optional resource.
unsigned int MediaAccessId
Media manager access Id type.
Definition: MediaSource.h:29
void operator()(media::MediaAccessId media, const Pathname &file)
Pathname localPath(MediaAccessId accessId, const Pathname &pathname) const
Shortcut for &#39;localRoot() + pathname&#39;, but returns an empty pathname if media is not attached...
void releaseFile(const OnMediaLocation &resource)
Release file from media.
unsigned medianr() const
media number where the resource is located.
void release(MediaAccessId accessId, const std::string &ejectDev="")
Release the attached media and optionally eject.
#define ZYPP_RETHROW(EXCPT)
Drops a logline and rethrows, updating the CodeLocation.
Definition: Exception.h:400
Do not differentiate case.
Definition: Regex.h:91
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
const std::string & asString() const
String representation.
Definition: Pathname.h:90
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.
std::string asUserHistory() const
A single (multiline) string composed of asUserString and historyAsString.
Definition: Exception.cc:91
#define WAR
Definition: Logger.h:65
std::list< DirEntry > DirContent
Returned by readdir.
Definition: PathInfo.h:547
int hardlinkCopy(const Pathname &oldpath, const Pathname &newpath)
Create newpath as hardlink or copy of oldpath.
Definition: PathInfo.cc:836
void addVerifier(MediaAccessId accessId, const MediaVerifierRef &verifier)
Add verifier implementation for the specified media id.
void operator()(media::MediaAccessId media, const Pathname &file)
std::string numstring(char n, int w=0)
Definition: String.h:288
void provideDir(MediaAccessId accessId, const Pathname &dirname) const
FIXME: see MediaAccess class.
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:396
const Pathname & filename() const
The path to the resource relatve to the url and path.
Regular expression match result.
Definition: Regex.h:145
Manages access to the &#39;physical&#39; media, e.g CDROM drives, Disk volumes, directory trees...
Definition: MediaManager.h:473
Base class for Exception.
Definition: Exception.h:145
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:199
std::string getPathName(EEncoding eflag=zypp::url::E_DECODED) const
Returns the path name from the URL.
Definition: Url.cc:598
MediaVerifierRef verifier
Wrapper for const correct access via Smart pointer types.
Definition: PtrTypes.h:285
media::MediaAccessId getMediaAccessId(media::MediaNr medianr)
Reference counted access to a Tp object calling a custom Dispose function when the last AutoDispose h...
Definition: AutoDispose.h:92
bool regex_match(const std::string &s, smatch &matches, const regex &regex)
regex ZYPP_STR_REGEX regex ZYPP_STR_REGEX
Definition: Regex.h:70
bool isAttached(MediaAccessId accessId) const
Check if media is attached or not.
void operator()(media::MediaAccessId media, const Pathname &file)
void releaseAll()
Release all attached media.
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 ...
Easy-to use interface to the ZYPP dependency resolver.
Definition: CodePitfalls.doc:1
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.
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.
Media access layer responsible for handling files distributed on a set of media with media change and...
void releaseFile(MediaAccessId accessId, const Pathname &filename) const
FIXME: see MediaAccess class.
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
static ManagedFile asManagedFile()
Create a temporary file and convert it to a automatically cleaned up ManagedFile. ...
Definition: TmpPath.cc:230
The user is not asked anything, and the error exception is just propagated.
void provideFile(MediaAccessId accessId, const Pathname &filename) const
Provide provide file denoted by relative path below of the &#39;attach point&#39; of the specified media and ...