@SuppressWarnings("deprecation") @Override public void validateParameter(String parameterName, ModelNode value) throws OperationFailedException { super.validateParameter(parameterName, value); if (value.isDefined()) { String module = value.asString(); try { org.jboss.modules.ModuleIdentifier.fromString(module); } catch (IllegalArgumentException e) { throw new OperationFailedException(e.getMessage() + ": " + module, e); } } } }
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); } } }
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 ClassLoader loadModule(String moduleName) throws ConfigXMLParseException { try { return Module.getModuleFromCallerModuleLoader(ModuleIdentifier.fromString(moduleName)).getClassLoader(); } catch (ModuleLoadException e) { throw new ConfigXMLParseException(e); } } }
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(); }
static ModuleClassLoader getModuleClassLoader(final String moduleSpec) throws ModuleLoadException { ModuleLoader loader = Module.getCallerModuleLoader(); final Module module = loader.loadModule(ModuleIdentifier.fromString(moduleSpec)); GetModuleClassLoaderAction action = new GetModuleClassLoaderAction(module); return WildFlySecurityManager.isChecking() ? doPrivileged(action) : action.run(); }
loadedContext = (Context) ctor.newInstance(newEnvironment); } else { Module module = Module.getBootModuleLoader().loadModule(ModuleIdentifier.fromString(initialContextModule)); loader = module.getClassLoader(); final ClassLoader currentClassLoader = WildFlySecurityManager.getCurrentContextClassLoaderPrivileged();
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); } }
ModuleSpec.Builder builder = ModuleSpec.build(ModuleIdentifier.fromString(mId)); if (level == 0) { String classurl = AppModuleLoader.class
@Override public void deploy(DeploymentPhaseContext phaseContext) throws DeploymentUnitProcessingException { final DeploymentUnit unit = phaseContext.getDeploymentUnit(); final ModuleLoader moduleLoader = Module.getBootModuleLoader(); final ModuleSpecification moduleSpec = unit.getAttachment(Attachments.MODULE_SPECIFICATION); moduleSpec.addSystemDependency(new ModuleDependency(moduleLoader, TRANSACTION_API, false, false, true, false)); moduleSpec.addSystemDependency(new ModuleDependency(moduleLoader, ModuleIdentifier.fromString("org.wildfly.transaction.client"), false, false, true, false)); final CompositeIndex compositeIndex = unit.getAttachment(Attachments.COMPOSITE_ANNOTATION_INDEX); if (compositeIndex == null) { return; } final List<AnnotationInstance> transactionalAnnotations = compositeIndex.getAnnotations(DotName.createSimple(Transactional.class.getName())); final List<AnnotationInstance> transactionScopedAnnotations = compositeIndex.getAnnotations(DotName.createSimple(TransactionScoped.class.getName())); if (transactionalAnnotations.size() > 0 || transactionScopedAnnotations.size() > 0) { addJTSModuleDependencyToDeployment(unit); } }
@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); } }
/** * Returns the class loader of the given module or throws a {@code ConfigXMLParseException} if the module can not be loaded. * * @param moduleName the name of the module (can not be {@code null} * @return the class loader of the module * @throws ConfigXMLParseException if the module can not be loaded * */ static ClassLoader getClassLoaderFromModule(@Param XMLStreamReader reader, String moduleName) throws ConfigXMLParseException { final ModuleIdentifier identifier = ModuleIdentifier.fromString(moduleName); try { return Module.getModuleFromCallerModuleLoader(identifier).getClassLoader(); } catch (ModuleLoadException e) { throw xmlLog.xmlNoModuleFound(reader, e, identifier.toString()); } } }
final Module module; try { moduleId = ModuleIdentifier.fromString(moduleName); module = Module.getCallerModuleLoader().loadModule(moduleId); } catch (ModuleNotFoundException e) {
@Override public void visit(ConfigVisitor visitor) { if (moduleName != null) { ModuleIdentifier identifier = ModuleIdentifier.fromString(moduleName); if (moduleName.startsWith(ServiceModuleLoader.MODULE_PREFIX)) { ServiceName serviceName = ServiceModuleLoader.moduleServiceName(identifier); visitor.addDependency(serviceName, getInjectedModule()); } else { Module dm = visitor.loadModule(identifier); getInjectedModule().setValue(new ImmediateValue<Module>(dm)); } } else { getInjectedModule().setValue(new ImmediateValue<Module>(visitor.getModule())); } // no children, no need to visit }
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; }
ClassLoader cl = module.getClassLoader(); if (hander.getModule() != null) { Module handlerModule = deploymentUnit.getAttachment(Attachments.SERVICE_MODULE_LOADER).loadModule(ModuleIdentifier.fromString(hander.getModule())); cl = handlerModule.getClassLoader();
/** * Get the module identifier for the module which is specified by this object. * * @return the module identifier * @deprecated Use {@link #getName()} instead. */ public ModuleIdentifier getModuleIdentifier() { return ModuleIdentifier.fromString(name); }
/** * Get the identifier of the module being defined by this builder. * * @return the module identifier * @deprecated use {@link #getName()} instead */ @Deprecated default ModuleIdentifier getIdentifier() { return ModuleIdentifier.fromString(getName()); }
/** * Get the identifier of the module being defined by this builder. * * @return the module identifier * @deprecated Use {@link #getName()} instead. */ @Deprecated default ModuleIdentifier getIdentifier() { return ModuleIdentifier.fromString(getName()); }
static ClassLoader getClassLoader(final String moduleName) throws Exception { ModuleLoader moduleLoader = ModuleLoader.forClass(ModuleFinder.class); if (moduleLoader == null) { moduleLoader = Module.getBootModuleLoader(); } return moduleLoader.loadModule(ModuleIdentifier.fromString(moduleName)).getClassLoader(); } }