public ClassLoader getWebComponentClassLoader(URI componentId) { return classLoaderRegistry.getClassLoader(componentId); }
ClassLoader targetClassLoader = classLoaderRegistry.getClassLoader(targetId); keyType = classLoaderRegistry.loadClass(targetClassLoader, sourceDefinition.getKeyClassName()); } catch (ClassNotFoundException e) { throw new KeyInstantiationException("Error loading reference key type for: " + sourceDefinition.getUri(), e);
private void buildCommonClassLoaderEnvironment(PhysicalClassLoaderDefinition definition) { URI uri = definition.getUri(); // Create an alias to the host classloader which contains all contribution artifacts in a non-isolated environment. // This simulates multiple classloaders ClassLoader hostClassLoader = classLoaderRegistry.getClassLoader(HOST_CONTRIBUTION); classLoaderRegistry.register(uri, hostClassLoader); }
public void destroy(URI uri) throws ClassLoaderBuilderException { ClassLoader classLoader = classLoaderRegistry.getClassLoader(uri); int val = tracker.decrement(classLoader); if (val == 0 && metaDataStore.find(uri) == null) { // Note the MetaDataStore is used to determine if a contribution classloader must be tracked. If a contribution is registered in the // store, it is installed as an extension of the base runtime distribution and should only be uninstalled explicitly. try { classLoaderRegistry.unregister(uri); // release the previously resolved contribution resolver.release(uri); } catch (ResolutionException e) { throw new ClassLoaderBuilderException("Error releasing artifact: " + uri.toString(), e); } for (ClassLoaderListener listener : listeners) { listener.onUndeploy(classLoader); } } else if (val == 0) { // single VM, do not remove the classloader since it is used by the installed contribution. Just notify listeners for (ClassLoaderListener listener : listeners) { listener.onUndeploy(classLoader); } } }
public Class<?> transform(Node node, ClassLoader loader) throws TransformationException { try { return classLoaderRegistry.loadClass(loader, node.getTextContent()); } catch (ClassNotFoundException e) { throw new TransformationException(e); } } }
classLoaderRegistry.register(contributionUri, loader); return contribution;
public void destroy() throws Fabric3Exception { // destroy system components WorkContextCache.getAndResetThreadWorkContext(); scopeContainer.stopAllContexts(); classLoaderRegistry.close(); }
public Class<?> transform(String source, ClassLoader loader) throws TransformationException { try { return classLoaderRegistry.loadClass(loader, source); } catch (ClassNotFoundException e) { throw new TransformationException(e); } }
classLoaderRegistry.register(contributionUri, loader); return contribution;
public void destroy() throws Fabric3Exception { // destroy system components WorkContextCache.getAndResetThreadWorkContext(); scopeContainer.stopAllContexts(); classLoaderRegistry.close(); }
private ClassLoader createParentClassLoader(URI parentClassLoaderId, URI id) { ClassLoader cl = classLoaderRegistry.getClassLoader(parentClassLoaderId); return new MultiParentClassLoader(id, cl); }
public ObjectFactory<?> createObjectFactory(MonitorTargetDefinition target) throws WiringException { try { ClassLoader loader = classLoaderRegistry.getClassLoader(target.getClassLoaderId()); Class<?> type = classLoaderRegistry.loadClass(loader, target.getMonitorType()); Component monitorable = componentManager.getComponent(target.getMonitorable()); Object monitor = monitorService.createMonitor(type, monitorable, target.getDestination()); return new SingletonObjectFactory<Object>(monitor); } catch (ClassNotFoundException e) { throw new WireAttachException("Unable to load monitor class: " + target.getMonitorType(), e); } catch (MonitorCreationException e) { throw new WireAttachException("Unable to create monitor for class: " + target.getMonitorType(), e); } } }
private void buildIsolatedClassLoaderEnvironment(PhysicalClassLoaderDefinition definition) throws ClassLoaderBuilderException { URI uri = definition.getUri(); // build the classloader using the locally cached resources ClassLoader hostClassLoader = classLoaderRegistry.getClassLoader(HOST_CONTRIBUTION); MultiParentClassLoader loader; if (definition.isProvisionArtifact()) { URL[] classpath = resolveClasspath(definition); loader = new MultiParentClassLoader(uri, classpath, hostClassLoader); setSysPathsField(loader); } else { loader = new MultiParentClassLoader(uri, hostClassLoader); } for (PhysicalClassLoaderWireDefinition wireDefinition : definition.getWireDefinitions()) { wireBuilder.build(loader, wireDefinition); URI target = wireDefinition.getTargetClassLoader(); ClassLoader classLoader = classLoaderRegistry.getClassLoader(target); tracker.incrementImported(classLoader); } classLoaderRegistry.register(uri, loader); }
private Map<Class<?>, Constructor<?>> getFaultMapping(ClassLoader classLoader, Set<String> faultNames) throws ClassNotFoundException, NoSuchMethodException { Map<Class<?>, Constructor<?>> mapping = new HashMap<Class<?>, Constructor<?>>(faultNames.size()); for (String faultName : faultNames) { Class<?> clazz = classLoaderRegistry.loadClass(classLoader, faultName); WebFault fault = clazz.getAnnotation(WebFault.class); if (fault == null) { // FIXME throw someting throw new RuntimeException(); } Method getFaultInfo = clazz.getMethod("getFaultInfo"); Class<?> faultType = getFaultInfo.getReturnType(); Constructor<?> constructor = clazz.getConstructor(String.class, faultType); mapping.put(faultType, constructor); } return mapping; } }
classLoaderRegistry.register(contributionUri, loader); return contribution;
@Init public void init() { MultiParentClassLoader jndiClassLoader = (MultiParentClassLoader) registry.getClassLoader(URI.create("f3-jndi")); if (jndiClassLoader == null) { return; } MultiParentClassLoader extensionClassLoader = (MultiParentClassLoader) getClass().getClassLoader(); extensionClassLoader.getParents().forEach(jndiClassLoader::addParent); } }
private JAXBContext getJAXBContext(ClassLoader classLoader, Set<String> classNames) throws JAXBException, ClassNotFoundException { Class<?>[] classes = new Class<?>[classNames.size()]; int i = 0; for (String className : classNames) { classes[i++] = classLoaderRegistry.loadClass(classLoader, className); } ClassLoader old = Thread.currentThread().getContextClassLoader(); try { // The JAXBContext searches the TCCL for the JAXB-RI. Set the TCCL to the Axis classloader (which loaded this class), as it has // visibility to the JAXB RI. Thread.currentThread().setContextClassLoader(getClass().getClassLoader()); return JAXBContext.newInstance(classes); } finally { Thread.currentThread().setContextClassLoader(old); } }
public void execute(DetachExtensionCommand command) throws ExecutionException { if (!info.supportsClassLoaderIsolation()) { return; } URI contributionUri = command.getContribution(); URI providerUri = command.getProvider(); // note: casts are safe as all extension and provider classloaders are multi-parent MultiParentClassLoader contributionCl = (MultiParentClassLoader) classLoaderRegistry.getClassLoader(contributionUri); MultiParentClassLoader providerCl = (MultiParentClassLoader) classLoaderRegistry.getClassLoader(providerUri); contributionCl.removeExtensionClassLoader(providerCl); } }
String param = params.get(i); try { paramTypes[i] = classLoaderRegistry.loadClass(loader, param); } catch (ClassNotFoundException e) { URI sourceUri = sourceDefinition.getUri();
/** * Loads a service contract class in either a host environment that supports classloader isolation or one that does not, in which case the TCCL is used. * * @param javaContract the contract * @param contributionUri the contribution URI the contract class is loaded in * @return the loaded class */ private Class<?> loadServiceClass(JavaServiceContract javaContract, URI contributionUri) throws GenerationException { ClassLoader loader = classLoaderRegistry.getClassLoader(contributionUri); try { return loader.loadClass(javaContract.getInterfaceClass()); } catch (ClassNotFoundException e) { throw new GenerationException(e); } }