/**
* Resolves all spaces represented by the given query uri
*
* @param queryUri Data Spaces URI to query for; must be URI without space part being fully
* defined, i.e. not pointing to any concrete data space; result spaces for that queries must
* be suitable for user path.
* @param ownerActiveObjectId Id of active object requesting this files, that will become owner of
* returned {@link DataSpacesFileObject} instances. May be <code>null</code>, which
* corresponds to anonymous (unimportant) owner.
* @return
* @throws FileSystemException
*/
public Map<DataSpacesURI, DataSpacesFileObject> resolveSpaces(
final DataSpacesURI queryUri, final String ownerActiveObjectId) throws FileSystemException {
final Map<DataSpacesURI, DataSpacesFileObject> result =
new HashMap<DataSpacesURI, DataSpacesFileObject>();
if (logger.isDebugEnabled())
logger.debug("[VFSMountManager] Spaces access request: " + queryUri);
final Set<SpaceInstanceInfo> spaces = directory.lookupMany(queryUri);
if (spaces != null) {
for (final SpaceInstanceInfo space : spaces) {
final DataSpacesURI spaceUri = space.getMountingPoint();
if (!spaceUri.isSuitableForUserPath()) {
logger.error(
"[VFSMountManager] Resolved space is not suitable for user path: " + spaceUri);
throw new IllegalArgumentException(
"Resolved space is not suitable for user path: " + spaceUri);
}
try {
ensureVirtualSpaceIsMounted(spaceUri, space);
} catch (SpaceNotFoundException e) {
ProActiveLogger.logImpossibleException(logger, e);
throw new RuntimeException(e);
}
result.put(spaceUri, doResolveFile(spaceUri, ownerActiveObjectId, null));
}
}
return result;
}
/**
* Ensures that the provided virtual space is mounted (at least one VFS file system is mounted)
*
* @param spaceURI uri of the virtual space
* @param info dataspace info
* @throws SpaceNotFoundException
* @throws FileSystemException
*/
private void ensureVirtualSpaceIsMounted(final DataSpacesURI spaceURI, SpaceInstanceInfo info)
throws SpaceNotFoundException, FileSystemException {
final boolean mounted;
DataSpacesURI spacePart = spaceURI.getSpacePartOnly();
try {
readLock.lock();
mounted = mountedSpaces.containsKey(spacePart);
} finally {
readLock.unlock();
}
if (!mounted) {
if (info == null) {
info = directory.lookupOne(spaceURI);
}
if (info == null) {
logger.warn(
"[VFSMountManager] Could not find data space in spaces directory: " + spacePart);
throw new SpaceNotFoundException(
"Requested data space is not registered in spaces directory.");
}
try {
readLock.lock();
if (mountedSpaces.containsKey(spacePart) && (mountedSpaces.get(spacePart).size() > 0))
return;
} finally {
readLock.unlock();
}
mountFirstAvailableFileSystem(info);
}
}
/**
* Unmount all file systems for the given dataspace
*
* @param spaceUri dataspace uri
*/
private void unmountAllFileSystems(final DataSpacesURI spaceUri) {
DataSpacesURI spacePart = spaceUri.getSpacePartOnly();
final ConcurrentHashMap<String, FileObject> spaceRoots = mountedSpaces.remove(spacePart);
VFSMountManagerHelper.closeFileSystems(spaceRoots.keySet());
}
/**
* resolves the given virtual uri into a DataSpaceFileObject. The VFS root is forced to the
* spaceRootFOUri parameter. Mount the space if necessary
*
* @param queryUri Data Spaces URI to get access to
* @param ownerActiveObjectId Id of active object requesting this file, that will become owner of
* returned {@link DataSpacesFileObject} instance. May be <code>null</code>, which corresponds
* to anonymous (unimportant) owner.
* @param spaceRootFOUri forces the use of the provided VFS space root (in case there are several
* roots)
* @return
* @throws FileSystemException
* @throws SpaceNotFoundException
*/
public DataSpacesFileObject resolveFile(
final DataSpacesURI queryUri, final String ownerActiveObjectId, String spaceRootFOUri)
throws FileSystemException, SpaceNotFoundException {
if (logger.isDebugEnabled()) logger.debug("[VFSMountManager] File access request: " + queryUri);
if (!queryUri.isSuitableForUserPath()) {
logger.error(
"[VFSMountManager] Requested URI " + queryUri + " is not suitable for user path");
throw new IllegalArgumentException(
"Requested URI " + queryUri + " is not suitable for user path");
}
final DataSpacesURI spaceURI = queryUri.getSpacePartOnly();
ensureVirtualSpaceIsMounted(spaceURI, null);
return doResolveFile(queryUri, ownerActiveObjectId, spaceRootFOUri);
}
/**
* Makes sure that the provided file system is mounted for the given dataspace (identified by its
* root url)
*
* @param mountingPoint dataspace uri
* @param spaceRootFOUri file system root
* @return true if the file system is mounted
* @throws FileSystemException
*/
private boolean ensureFileSystemIsMounted(
final DataSpacesURI mountingPoint, final String spaceRootFOUri) throws FileSystemException {
ConcurrentHashMap<String, FileObject> fileSystems = null;
DataSpacesURI spacePart = mountingPoint.getSpacePartOnly();
try {
readLock.lock();
fileSystems = mountedSpaces.get(spacePart);
// already mounted
if (fileSystems.get(spaceRootFOUri) != null) {
return true;
}
} finally {
readLock.unlock();
}
logger.debug("[VFSMountManager] Request mounting VFS root = " + spaceRootFOUri);
FileObject mountedRoot;
try {
mountedRoot = VFSMountManagerHelper.mount(spaceRootFOUri);
// the fs is accessible
try {
writeLock.lock();
fileSystems.put(spaceRootFOUri, mountedRoot);
mountedSpaces.put(spacePart, fileSystems);
} finally {
writeLock.unlock();
}
if (logger.isDebugEnabled())
logger.debug(
String.format(
"[VFSMountManager] Mounted space: %s (access URL: %s)", spacePart, spaceRootFOUri));
return true;
} catch (org.apache.commons.vfs.FileSystemException x) {
String err =
String.format(
"[VFSMountManager] Could not access URL %s to mount %s", spaceRootFOUri, spacePart);
logger.info(err);
removeSpaceRootUri(spacePart, spaceRootFOUri);
throw new FileSystemException(err, x);
}
}
@Test
public void test()
throws ApplicationAlreadyRegisteredException, WrongApplicationIdException,
SpaceAlreadyRegisteredException, IllegalArgumentException {
Set<SpaceInstanceInfo> spaces = new HashSet<SpaceInstanceInfo>();
Set<Long> appsRegistered;
spaces.add(spaceInstanceInput1);
spaces.add(spaceInstanceInput2);
spaces.add(spaceInstanceOutput1);
spaces.add(spaceInstanceOutput2);
assertFalse(stub.isApplicationIdRegistered(MAIN_APPID));
// TEST REGISTER APP
logger.info("Test register application");
stub.registerApplication(MAIN_APPID, spaces);
// check if everything has been registered
logger.info("Checking that application has been registered");
assertTrue(stub.isApplicationIdRegistered(MAIN_APPID));
appsRegistered = stub.getRegisteredApplications();
appsRegistered.contains(MAIN_APPID);
// TEST LOOKUP FIRST
logger.info("Test Lookup First");
assertIsSpaceRegistered(spaceInstanceInput1);
assertIsSpaceRegistered(spaceInstanceInput2);
assertIsSpaceRegistered(spaceInstanceOutput1);
assertIsSpaceRegistered(spaceInstanceOutput2);
// TEST LOOKUP ALL
logger.info("Test Lookup All");
final DataSpacesURI query = DataSpacesURI.createURI(MAIN_APPID);
final Set<SpaceInstanceInfo> actual = stub.lookupMany(query);
assertEquals(spaces, actual);
// TEST UNREGISTER
logger.info("Test unregister");
assertTrue(stub.unregister(spaceInstanceInput1.getMountingPoint()));
assertTrue(stub.unregister(spaceInstanceOutput1.getMountingPoint()));
// TEST LOOKUP FIRST WITH NULL ANSWER
logger.info("Test looup first with null answer");
assertIsSpaceUnregistered(spaceInstanceInput1);
assertIsSpaceUnregistered(spaceInstanceOutput1);
// TEST REGISTER
logger.info("Test register");
stub.register(spaceInstanceInput1);
stub.register(spaceInstanceOutput1);
// TEST EXCEPTION WHEN SPACE ALREADY REGISTERED
logger.info("Test Exception when space already registered");
try {
stub.register(spaceInstanceInput1);
fail("Exception expected");
} catch (SpaceAlreadyRegisteredException e) {
} catch (Exception e) {
fail("Expected exception of different type");
}
// TEST EXCEPTION WHEN APP NOT REGISTERED
logger.info("Test Exception when app not registered");
try {
stub.register(spaceInstanceInput1b);
fail("Exception expected");
} catch (WrongApplicationIdException e) {
} catch (Exception e) {
fail("Expected exception of different type");
}
// TEST EXCEPTION WHEN APP ALREADY REGISTERED
logger.info("Test Exception when app already registered");
try {
stub.registerApplication(MAIN_APPID, null);
fail("Exception expected");
} catch (ApplicationAlreadyRegisteredException e) {
} catch (Exception e) {
fail("Expected exception of different type");
}
// TEST UNREGISTER APP
logger.info("Test unregister");
stub.unregisterApplication(MAIN_APPID);
}
/**
* Internal method for resolving a file, will mount the file system if it is not mounted yet
*
* @param uri virtual uri of the file
* @param ownerActiveObjectId Id of active object requesting this file
* @param spaceRootFOUri root file system to use
* @return
* @throws FileSystemException
*/
private DataSpacesFileObject doResolveFile(
final DataSpacesURI uri, final String ownerActiveObjectId, String spaceRootFOUri)
throws FileSystemException {
DataSpacesURI spacePart = uri.getSpacePartOnly();
if (spaceRootFOUri != null) {
ensureFileSystemIsMounted(spacePart, spaceRootFOUri);
} else {
try {
readLock.lock();
LinkedHashSet<String> los = accessibleFileObjectUris.get(spacePart);
spaceRootFOUri = los.iterator().next();
} finally {
readLock.unlock();
}
ensureFileSystemIsMounted(spacePart, spaceRootFOUri);
}
final String relativeToSpace = uri.getRelativeToSpace();
try {
readLock.lock();
if (!mountedSpaces.containsKey(spacePart)) {
throw new FileSystemException("Could not access file that should exist (be mounted)");
}
final ConcurrentHashMap<String, FileObject> spaceRoots = mountedSpaces.get(spacePart);
FileObject spaceRoot = spaceRoots.get(spaceRootFOUri);
FileName dataSpaceVFSFileName = null;
final FileObject file;
// the dataspace "File name" (it is actually a File Path) is computed using the Virtual Space
// root
if (dataSpaceVFSFileName == null) {
dataSpaceVFSFileName = spaceRoot.getName();
}
try {
if (relativeToSpace == null) file = spaceRoot;
else file = spaceRoot.resolveFile(relativeToSpace);
final DataSpacesLimitingFileObject limitingFile =
new DataSpacesLimitingFileObject(
file, spacePart, spaceRoot.getName(), ownerActiveObjectId);
return new VFSFileObjectAdapter(
limitingFile,
spacePart,
dataSpaceVFSFileName,
new ArrayList<String>(accessibleFileObjectUris.get(spacePart)),
spaceRootFOUri,
this,
ownerActiveObjectId);
} catch (org.apache.commons.vfs.FileSystemException x) {
logger.error("[VFSMountManager] Could not access file within a space: " + uri);
throw new FileSystemException(x);
} catch (FileSystemException e) {
ProActiveLogger.logImpossibleException(logger, e);
throw new ProActiveRuntimeException(e);
}
} finally {
readLock.unlock();
}
}
/**
* Mounts the first available VFS file system on the given dataspace
*
* @param spaceInfo space information
* @throws FileSystemException if no file system could be mounted
*/
private void mountFirstAvailableFileSystem(final SpaceInstanceInfo spaceInfo)
throws FileSystemException {
final DataSpacesURI mountingPoint = spaceInfo.getMountingPoint();
try {
writeLock.lock();
if (!mountedSpaces.containsKey(mountingPoint)) {
mountedSpaces.put(mountingPoint, new ConcurrentHashMap<String, FileObject>());
}
ConcurrentHashMap<String, FileObject> fileSystems = mountedSpaces.get(mountingPoint);
if (spaceInfo.getUrls().size() == 0) {
throw new IllegalStateException("Empty Space configuration");
}
DataSpacesURI spacePart = mountingPoint.getSpacePartOnly();
ArrayList<String> urls = new ArrayList<String>(spaceInfo.getUrls());
if (urls.size() == 1) {
urls.add(
0, Utils.getLocalAccessURL(urls.get(0), spaceInfo.getPath(), spaceInfo.getHostname()));
}
logger.debug("[VFSMountManager] Request mounting VFS root list : " + urls);
try {
VFSMountManagerHelper.mountAny(urls, fileSystems);
if (!accessibleFileObjectUris.containsKey(mountingPoint)) {
LinkedHashSet<String> srl = new LinkedHashSet<String>();
accessibleFileObjectUris.put(mountingPoint, srl);
}
LinkedHashSet<String> srl = accessibleFileObjectUris.get(mountingPoint);
for (String uri : urls) {
if (fileSystems.containsKey(uri)) {
srl.add(uri);
}
}
if (srl.isEmpty()) {
throw new IllegalStateException(
"Invalid empty size list when trying to mount "
+ urls
+ " mounted map content is "
+ fileSystems);
}
accessibleFileObjectUris.put(mountingPoint, srl);
if (logger.isDebugEnabled())
logger.debug(
String.format(
"[VFSMountManager] Mounted space: %s (access URL: %s)", spacePart, srl));
mountedSpaces.put(mountingPoint, fileSystems);
} catch (org.apache.commons.vfs.FileSystemException e) {
mountedSpaces.remove(mountingPoint);
throw new FileSystemException(
"An error occurred while trying to mount " + spaceInfo.getName(), e);
}
} finally {
writeLock.unlock();
}
}