/** \file zypp/media/MediaManager.cc
*
*/
-#include <zypp/media/MediaException.h>
-#include <zypp/media/MediaManager.h>
-#include <zypp/media/MediaHandler.h>
-#include <zypp/media/Mount.h>
-#include <zypp/thread/Mutex.h>
-#include <zypp/thread/MutexLock.h>
-#include <zypp/target/hal/HalContext.h>
-
-#include <zypp/base/String.h>
-#include <zypp/base/Logger.h>
-#include <zypp/Pathname.h>
-#include <zypp/PathInfo.h>
-
#include <map>
#include <list>
#include <iostream>
#include <typeinfo>
-#define DISABLE_AUTOMOUNTER 0
+#include "zypp/media/MediaException.h"
+#include "zypp/media/MediaManager.h"
+#include "zypp/media/MediaHandler.h"
+#include "zypp/media/Mount.h"
+#include "zypp/thread/Mutex.h"
+#include "zypp/thread/MutexLock.h"
+#include "zypp/base/String.h"
+#include "zypp/base/Logger.h"
+#include "zypp/Pathname.h"
+#include "zypp/PathInfo.h"
//////////////////////////////////////////////////////////////////////
namespace zypp
}
}
- inline void
- checkDesired(MediaAccessId id)
+ inline void checkDesired( MediaAccessId id )
{
- checkAttached(id);
+ checkAttached( id );
- if( !desired)
+ if ( !desired )
{
- try {
- desired = verifier->isDesiredMedia(handler);
- }
- catch(const zypp::Exception &e) {
- ZYPP_CAUGHT(e);
- desired = false;
- }
+ desired = verifier->isDesiredMedia(handler);
- if( !desired)
+ if( !desired )
{
- DBG << "checkDesired(" << id << "): not desired (report by "
- << verifier->info() << ")" << std::endl;
- ZYPP_THROW(MediaNotDesiredException(
- handler->url()
- ));
+ DBG << "checkDesired(" << id << "): not desired (report by " << verifier->info() << ")" << std::endl;
+ ZYPP_THROW( MediaNotDesiredException( handler->url() ) );
}
- DBG << "checkDesired(" << id << "): desired (report by "
- << verifier->info() << ")" << std::endl;
+ DBG << "checkDesired(" << id << "): desired (report by " << verifier->info() << ")" << std::endl;
} else {
DBG << "checkDesired(" << id << "): desired (cached)" << std::endl;
}
// -------------------------------------------------------------
typedef std::map<MediaAccessId, ManagedMedia> ManagedMediaMap;
-
- // -------------------------------------------------------------
- enum AutoMounterCleanUp
- {
- NONE, ENABLE, REMOVE
- };
-
- #define HAL_AUTOMOUNTER_UDI "/org/freedesktop/Hal/devices/computer"
- #define HAL_AUTOMOUNTER_KEY "storage.disable_volume_handling"
-
- // -------------------------------------------------------------
- AutoMounterCleanUp
- disableAutoMounter()
- {
- using namespace zypp::target::hal;
-
- AutoMounterCleanUp cleanup(NONE);
-#if DISABLE_AUTOMOUNTER
- try
- {
- HalContext hal(true);
- bool disabled(false);
-
- // query
- XXX << "Checking HAL volume handling property"
- << std::endl;
- try
- {
- disabled = hal.getDevicePropertyBool(
- HAL_AUTOMOUNTER_UDI, HAL_AUTOMOUNTER_KEY
- );
-
- if( disabled)
- {
- MIL << "HAL volume handling is already disabled"
- << std::endl;
- }
- else
- {
- cleanup = ENABLE;
- XXX << "HAL volume handling is enabled"
- << std::endl;
- }
- }
- catch(const HalException &e)
- {
- ZYPP_CAUGHT(e);
- XXX << "HAL volume handling is enabled (no property)"
- << std::endl;
- disabled = false;
- cleanup = REMOVE;
- }
-
- // disable
- if( !disabled)
- {
- XXX << "Trying to disable HAL volume handling"
- << std::endl;
- try
- {
- hal.setDevicePropertyBool(
- HAL_AUTOMOUNTER_UDI, HAL_AUTOMOUNTER_KEY,
- true
- );
-
- MIL << "Disabled HAL volume handling (automounter)"
- << std::endl;
- }
- catch(const HalException &e)
- {
- ZYPP_CAUGHT(e);
- WAR << "Unable to disable HAL volume handling (automounter)"
- << std::endl;
-
- cleanup = NONE;
- }
- }
- }
- catch(const HalException &e)
- {
- ZYPP_CAUGHT(e);
- WAR << "Unable to disable HAL volume handling (automounter)"
- << std::endl;
- }
-#endif // DISABLE_AUTOMOUNTER
- return cleanup;
- }
-
- // -------------------------------------------------------------
- void
- restoreAutoMounter(AutoMounterCleanUp cleanup)
- {
- using namespace zypp::target::hal;
-
- if(cleanup == NONE)
- return;
-
-#if DISABLE_AUTOMOUNTER
- try
- {
- HalContext hal(true);
-
- if(cleanup == ENABLE)
- {
- XXX << "Trying to restore HAL volume handling -- enable"
- << std::endl;
-
- hal.setDevicePropertyBool(
- HAL_AUTOMOUNTER_UDI, HAL_AUTOMOUNTER_KEY,
- false
- );
- }
- else
- if(cleanup == REMOVE)
- {
- XXX << "Trying to restore HAL volume handling -- remove"
- << std::endl;
-
- hal.removeDeviceProperty(
- HAL_AUTOMOUNTER_UDI, HAL_AUTOMOUNTER_KEY
- );
- }
-
- cleanup = NONE;
- MIL << "Restored HAL volume handling (automounter)"
- << std::endl;
- }
- catch(const HalException &e)
- {
- ZYPP_CAUGHT(e);
- WAR << "Unable to restore HAL volume handling (automounter)"
- << std::endl;
- }
-#endif // DISABLE_AUTOMOUNTER
- }
-
////////////////////////////////////////////////////////////////
} // anonymous
//////////////////////////////////////////////////////////////////
friend class MediaManager;
MediaAccessId last_accessid;
- AutoMounterCleanUp am_cleanup;
ManagedMediaMap mediaMap;
MediaManager_Impl()
: last_accessid(0)
- {
- // disable automounter
- am_cleanup = disableAutoMounter();
- }
+ {}
public:
~MediaManager_Impl()
// remove all other handlers
mediaMap.clear();
-
- // restore automounter state
- restoreAutoMounter(am_cleanup);
}
catch( ... )
{}
static inline MountEntries
getMountEntries()
{
- // use "/etc/mtab" by default,
- // fallback to "/proc/mounts"
- return Mount::getEntries(/* "/etc/mtab" */);
+ return Mount::getEntries();
}
};
//////////////////////////////////////////////////////////////////
// STATIC
- zypp::RW_pointer<MediaManager_Impl> MediaManager::m_impl(NULL);
+ zypp::RW_pointer<MediaManager_Impl> MediaManager::m_impl;
//////////////////////////////////////////////////////////////////
}
// ---------------------------------------------------------------
- // STATIC
- bool
- MediaManager::downloads(const Url &url)
- {
- return MediaAccess::downloads( url);
- }
-
- // ---------------------------------------------------------------
Url
MediaManager::url(MediaAccessId accessId) const
{
}
// ---------------------------------------------------------------
- void
- MediaManager::attach(MediaAccessId accessId, bool next)
+ void MediaManager::attach(MediaAccessId accessId)
{
MutexLock glock(g_Mutex);
ManagedMedia &ref( m_impl->findMM(accessId));
DBG << "attach(id=" << accessId << ")" << std::endl;
-
- return ref.handler->attach(next);
- }
-
- // ---------------------------------------------------------------
- void MediaManager::attachDesiredMedia(MediaAccessId accessId)
- {
- MutexLock glock(g_Mutex);
-
- ManagedMedia &ref( m_impl->findMM(accessId));
-
- DBG << "attach(id=" << accessId << ")" << std::endl;
// try first mountable/mounted device
ref.handler->attach(false);
ZYPP_RETHROW(ex);
AttachedMedia media(ref.handler->attachedMedia());
- DBG << "Skipping " << media.mediaSource->asString() << " because of exception thrown by attach(true)" << std::endl;
+ DBG << "Skipping " << media.mediaSource->asString() << " because of exception thrown by attach(true)" << std::endl;
if (ref.handler->isAttached()) ref.handler->release();
}
{
DBG << "Releasing media id " << m->first << std::endl;
m->second.desired = false;
- m->second.handler->release(false);
+ m->second.handler->release();
}
else
{
// ---------------------------------------------------------------
void
MediaManager::provideFile(MediaAccessId accessId,
- const Pathname &filename,
- bool cached,
- bool checkonly) const
+ const Pathname &filename ) const
+ {
+ MutexLock glock(g_Mutex);
+
+ ManagedMedia &ref( m_impl->findMM(accessId));
+
+ ref.checkDesired(accessId);
+
+ ref.handler->provideFile(filename);
+ }
+
+ // ---------------------------------------------------------------
+ void
+ MediaManager::setDeltafile(MediaAccessId accessId,
+ const Pathname &filename ) const
{
MutexLock glock(g_Mutex);
ref.checkDesired(accessId);
- ref.handler->provideFile(filename, cached, checkonly);
+ ref.handler->setDeltafile(filename);
}
// ---------------------------------------------------------------
return ref.handler->doesFileExist(filename);
}
-
+
+ // ---------------------------------------------------------------
+ void
+ MediaManager::getDetectedDevices(MediaAccessId accessId,
+ std::vector<std::string> & devices,
+ unsigned int & index) const
+ {
+ MutexLock glock(g_Mutex);
+ ManagedMedia &ref( m_impl->findMM(accessId));
+ return ref.handler->getDetectedDevices(devices, index);
+ }
+
// ---------------------------------------------------------------
// STATIC
time_t
AttachedMedia ret = m->second.handler->attachedMedia();
if( ret.mediaSource && ret.mediaSource->equals( *media))
{
- m->second.handler->release(false);
+ m->second.handler->release();
m->second.desired = false;
}
}