/** * 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; }
private void assertIsSpaceUnregistered(SpaceInstanceInfo expected) { assertNull(stub.lookupOne(expected.getMountingPoint())); }
private void assertIsSpaceRegistered(SpaceInstanceInfo expected) { SpaceInstanceInfo actual = stub.lookupOne(expected.getMountingPoint()); assertEquals(actual.getMountingPoint(), expected.getMountingPoint()); }
@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); }
/** * 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(); } }