Refine search
/** * Return the class loader associated to the JBoss Module identified by the {@code moduleName} * * @param moduleName the name of the module (can not be {@code null} * @return the class loader associated to the JBoss Module * @throws IOException if the module can not be loaded or if JBoss Modules is not present */ static ClassLoader getClassLoaderFromModule(String moduleName) throws IOException{ try { return Module.getCallerModuleLoader().loadModule(moduleName).getClassLoader(); } catch (ModuleLoadException e) { throw new IOException("Failed to create endpoint", e); } catch (LinkageError e) { throw new IOException("Failed to create endpoint: JBoss Modules is not present", e); } } }
private boolean isJSF12(ModuleDependency moduleDependency, String identifier) throws ModuleLoadException { // The class javax.faces.event.NamedEvent was introduced in JSF 2.0 return (moduleDependency.getModuleLoader().loadModule(identifier) .getClassLoader().getResource("/javax/faces/event/NamedEvent.class") == null); }
private static Class unwrapClass(ModelNode classModel) throws OperationFailedException { String className = classModel.get(NAME).asString(); String moduleName = classModel.get(MODULE).asString(); try { ModuleIdentifier moduleID = ModuleIdentifier.fromString(moduleName); Module module = Module.getCallerModuleLoader().loadModule(moduleID); Class<?> clazz = module.getClassLoader().loadClass(className); return clazz; } catch (Exception e) { throw ROOT_LOGGER.unableToLoadClassFromModule(className, moduleName); } } }
static Class<? extends Protocol> findProtocolClass(OperationContext context, String protocolName, String moduleName) throws OperationFailedException { String className = protocolName; if (moduleName.equals(AbstractProtocolResourceDefinition.Attribute.MODULE.getDefinition().getDefaultValue().asString()) && !protocolName.startsWith(org.jgroups.conf.ProtocolConfiguration.protocol_prefix)) { className = String.join(".", org.jgroups.conf.ProtocolConfiguration.protocol_prefix, protocolName); } try { return Module.getContextModuleLoader().loadModule(moduleName).getClassLoader().loadClass(className).asSubclass(Protocol.class); } catch (ClassNotFoundException | ModuleLoadException e) { throw JGroupsLogger.ROOT_LOGGER.unableToLoadProtocolClass(className); } } }
private static Class unwrapClass(ModelNode classModel) throws OperationFailedException { String className = classModel.get(NAME).asString(); String moduleName = classModel.get(MODULE).asString(); try { ModuleIdentifier moduleID = ModuleIdentifier.fromString(moduleName); Module module = Module.getCallerModuleLoader().loadModule(moduleID); Class<?> clazz = module.getClassLoader().loadClass(className); return clazz; } catch (Exception e) { throw ROOT_LOGGER.unableToLoadClassFromModule(className, moduleName); } } }
static ModuleClassLoader getModuleClassLoader(final ModuleLoader loader, final String moduleSpec) throws ModuleLoadException { final Module module = loader.loadModule(ModuleIdentifier.fromString(moduleSpec)); return WildFlySecurityManager.isChecking() ? doPrivileged(new GetModuleClassLoaderAction(module)) : module.getClassLoader(); }
private ObjectFactory factoryFromModularReference(ModularReference modularReference, final Hashtable<?, ?> environment) throws Exception { final Module module = Module.getCallerModuleLoader().loadModule(modularReference.getModuleIdentifier()); final ClassLoader classLoader = module.getClassLoader(); return factoryFromReference(modularReference, classLoader, environment); }
protected Class<?> getHandlerClass(String className, String moduleName) { ModuleLoader moduleLoader = Module.getBootModuleLoader(); try { Module filterModule = moduleLoader.loadModule(ModuleIdentifier.fromString(moduleName)); return filterModule.getClassLoader().loadClassLocal(className); } catch (ModuleLoadException | ClassNotFoundException e) { throw UndertowLogger.ROOT_LOGGER.couldNotLoadHandlerFromModule(className,moduleName,e); } }
@Override public final P createProtocol(ProtocolStackConfiguration stackConfiguration) { // A "native" protocol is one that is not specified as a class name boolean nativeProtocol = this.moduleName.equals(AbstractProtocolResourceDefinition.Attribute.MODULE.getDefinition().getDefaultValue().asString()) && !this.name.startsWith(org.jgroups.conf.ProtocolConfiguration.protocol_prefix); String className = nativeProtocol ? String.join(".", org.jgroups.conf.ProtocolConfiguration.protocol_prefix, this.name) : this.name; try { Module module = this.loader.get().loadModule(this.moduleName); Class<? extends Protocol> protocolClass = module.getClassLoader().loadClass(className).asSubclass(Protocol.class); Map<String, String> properties = new HashMap<>(this.defaults.get().getProperties(protocolClass)); properties.putAll(this.properties); PrivilegedExceptionAction<Protocol> action = () -> { try { return protocolClass.newInstance().setProperties(properties); } catch (InstantiationException | IllegalAccessException e) { throw new IllegalStateException(e); } }; @SuppressWarnings("unchecked") P protocol = (P) WildFlySecurityManager.doUnchecked(action); this.accept(protocol); protocol.enableStats(this.statisticsEnabled != null ? this.statisticsEnabled : stackConfiguration.isStatisticsEnabled()); return protocol; } catch (Exception e) { throw new IllegalArgumentException(e); } } }
/** {@inheritDoc} */ public Class<?> resolveClass(final Unmarshaller unmarshaller, final String className, final long serialVersionUID) throws IOException, ClassNotFoundException { final String name = (String) unmarshaller.readObject(); if (name == null) { return Class.forName(className, false, MODULE_CLASS_LOADER); } final String slot = (String) unmarshaller.readObject(); final ModuleIdentifier identifier = ModuleIdentifier.create(name, slot); try { final ClassLoader classLoader; final Module module = moduleLoader.loadModule(identifier); if (System.getSecurityManager() == null) { classLoader = module.getClassLoader(); } else { classLoader = AccessController.doPrivileged(new PrivilegedAction<ClassLoader>() { @Override public ClassLoader run() { return module.getClassLoader(); } }); } return Class.forName(className, false, classLoader); } catch (ModuleLoadException e) { final InvalidClassException ce = new InvalidClassException(className, "Module load failed"); ce.initCause(e); throw ce; } }
module = Module.getBootModuleLoader().loadModule(ModuleIdentifier.create("org.jboss.as.ee")); } catch (Throwable e) { throw new IOException(e); currentThread().setContextClassLoader(module.getClassLoader()); } else { AccessController.doPrivileged(new PrivilegedAction<Object>() {
/** {@inheritDoc} */ public Class<?> resolveProxyClass(final Unmarshaller unmarshaller, final String[] names) throws IOException, ClassNotFoundException { final String name = (String) unmarshaller.readObject(); final ClassLoader classLoader; if (name == null) { classLoader = MODULE_CLASS_LOADER; } else { final String slot = (String) unmarshaller.readObject(); final ModuleIdentifier identifier = ModuleIdentifier.create(name, slot); final Module module; try { module = moduleLoader.loadModule(identifier); } catch (ModuleLoadException e) { final InvalidClassException ce = new InvalidClassException("Module load failed"); ce.initCause(e); throw ce; } classLoader = module.getClassLoader(); } final int len = names.length; final Class<?>[] interfaces = new Class<?>[len]; for (int i = 0; i < len; i ++) { interfaces[i] = Class.forName(names[i], false, classLoader); } return Proxy.getProxyClass(classLoader, interfaces); } }
private static Class<?> loadClass(String driverName, String moduleName, String className) throws IllegalArgumentException { try { Module module = Module.getCallerModuleLoader().loadModule(moduleName); AgroalLogger.DRIVER_LOGGER.debugf("loaded module '%s' for driver: %s", moduleName, driverName); Class<?> providerClass = module.getClassLoader().loadClass(className); AgroalLogger.DRIVER_LOGGER.driverLoaded(className, driverName); return providerClass; } catch (ModuleLoadException e) { throw AgroalLogger.DRIVER_LOGGER.loadModuleException(e, moduleName); } catch (ClassNotFoundException e) { throw AgroalLogger.DRIVER_LOGGER.loadClassException(e, className); } }
loadedContext = (Context) ctor.newInstance(newEnvironment); } else { Module module = Module.getBootModuleLoader().loadModule(ModuleIdentifier.fromString(initialContextModule)); loader = module.getClassLoader(); final ClassLoader currentClassLoader = WildFlySecurityManager.getCurrentContextClassLoaderPrivileged(); try {
@Override public HttpHandler createHttpHandler(Predicate predicate, ModelNode model, HttpHandler next) { String expression = model.get(EXPRESSION.getName()).asString(); String moduleName = null; if (model.hasDefined(MODULE.getName())) { moduleName = model.get(MODULE.getName()).asString(); } ClassLoader classLoader; if (moduleName == null) { classLoader = getClass().getClassLoader(); } else { try { ModuleLoader moduleLoader = Module.getBootModuleLoader(); Module filterModule = moduleLoader.loadModule(ModuleIdentifier.fromString(moduleName)); classLoader = filterModule.getClassLoader(); } catch (ModuleLoadException e) { throw UndertowLogger.ROOT_LOGGER.couldNotLoadHandlerFromModule(expression, moduleName, e); } } List<PredicatedHandler> handlers = PredicatedHandlersParser.parse(expression, classLoader); UndertowLogger.ROOT_LOGGER.debugf("Creating http handler %s from module %s", expression, moduleName); if (predicate != null) { return Handlers.predicate(predicate, Handlers.predicates(handlers, next), next); } else { return Handlers.predicates(handlers, next); } }
className = (String) unmarshaller.readObject(); try { classLoader = moduleLoader.loadModule(identifier).getClassLoader(); } catch (ModuleLoadException e) { final InvalidClassException ce = new InvalidClassException(className, "Module load failed"); final Module module; try { module = moduleLoader.loadModule(identifier); } catch (ModuleLoadException e) { final InvalidClassException ce = new InvalidClassException("Module load failed"); throw ce; classLoader = module.getClassLoader();
try { ModuleIdentifier moduleId = ModuleIdentifier.create(moduleName, slot); module = Module.getCallerModuleLoader().loadModule(moduleId); } catch (ModuleNotFoundException e) { throw new OperationFailedException(ConnectorLogger.ROOT_LOGGER.raModuleNotFound(moduleName, e.getMessage()), e); final ServiceController<?> deployerService = context.getServiceRegistry(true).getService(deployerServiceName); if (deployerService == null) { ServiceBuilder builder = ParsedRaDeploymentProcessor.process(connectorXmlDescriptor, ironJacamarXmlDescriptor, module.getClassLoader(), serviceTarget, annotationIndexes, RAR_MODULE.append(name), null, null); builder.requires(raServiceName); newControllers.add(builder.setInitialMode(ServiceController.Mode.ACTIVE).install());
private ObjectFactory createObjectFactory(OperationContext context, ModelNode model) throws OperationFailedException { final ModuleIdentifier moduleID = ModuleIdentifier.fromString(NamingBindingResourceDefinition.MODULE.resolveModelAttribute(context, model).asString()); final String className = NamingBindingResourceDefinition.CLASS.resolveModelAttribute(context, model).asString(); final Module module; try { module = Module.getBootModuleLoader().loadModule(moduleID); } catch (ModuleNotFoundException e) { throw NamingLogger.ROOT_LOGGER.moduleNotFound(moduleID, e.getMessage()); } catch (ModuleLoadException e) { throw NamingLogger.ROOT_LOGGER.couldNotLoadModule(moduleID); } final ObjectFactory objectFactoryClassInstance; final ClassLoader cl = WildFlySecurityManager.getCurrentContextClassLoaderPrivileged(); try { WildFlySecurityManager.setCurrentContextClassLoaderPrivileged(module.getClassLoader()); final Class<?> clazz = module.getClassLoader().loadClass(className); objectFactoryClassInstance = (ObjectFactory) clazz.newInstance(); } catch (ClassNotFoundException e) { throw NamingLogger.ROOT_LOGGER.couldNotLoadClassFromModule(className, moduleID); } catch (InstantiationException e) { throw NamingLogger.ROOT_LOGGER.couldNotInstantiateClassInstanceFromModule(className, moduleID); } catch (IllegalAccessException e) { throw NamingLogger.ROOT_LOGGER.couldNotInstantiateClassInstanceFromModule(className, moduleID); } catch (ClassCastException e) { throw NamingLogger.ROOT_LOGGER.notAnInstanceOfObjectFactory(className, moduleID); } finally { WildFlySecurityManager.setCurrentContextClassLoaderPrivileged(cl); } return objectFactoryClassInstance; }
try { moduleId = ModuleIdentifier.fromString(moduleName); module = Module.getCallerModuleLoader().loadModule(moduleId); } catch (ModuleNotFoundException e) { context.getFailureDescription().set(ConnectorLogger.ROOT_LOGGER.missingDependencyInModuleDriver(moduleName, e.getMessage())); final Class<? extends Driver> driverClass = module.getClassLoader().loadClass(driverClassName) .asSubclass(Driver.class); final Constructor<? extends Driver> constructor = driverClass.getConstructor();
module = Module.getCallerModuleLoader().loadModule(moduleId); } catch (ModuleNotFoundException e) { throw new OperationFailedException(ConnectorLogger.ROOT_LOGGER.missingDependencyInModuleDriver(moduleName, e.getMessage()), e); Class<? extends DataSource> dsCls; try { dsCls = module.getClassLoader().loadClass(dataSourceClassName).asSubclass(DataSource.class); } catch (ClassNotFoundException | ClassCastException e) { throw SUBSYSTEM_DATASOURCES_LOGGER.failedToLoadDataSourceClass(dataSourceClassName, e); Class<? extends XADataSource> dsCls; try { dsCls = module.getClassLoader().loadClass(xaDataSourceClassName).asSubclass(XADataSource.class); } catch (ClassNotFoundException | ClassCastException e) { throw SUBSYSTEM_DATASOURCES_LOGGER.failedToLoadDataSourceClass(xaDataSourceClassName, e); } else { try { final Class<? extends Driver> driverClass = module.getClassLoader().loadClass(driverClassName) .asSubclass(Driver.class); final Constructor<? extends Driver> constructor = driverClass.getConstructor();