use of org.mule.runtime.module.extension.internal.loader.utils.ParameterDeclarationContext in project mule by mulesoft.
the class ConfigModelLoaderDelegate method declareConfiguration.
private void declareConfiguration(ExtensionDeclarer declarer, ExtensionElement extensionType, ComponentElement configType) {
checkConfigurationIsNotAnOperation(extensionType, configType);
ConfigurationDeclarer configurationDeclarer;
Optional<Configuration> configurationAnnotation = configType.getAnnotation(Configuration.class);
if (configurationAnnotation.isPresent()) {
final Configuration configuration = configurationAnnotation.get();
String configName = isBlank(configuration.name()) ? DEFAULT_CONFIG_NAME : configuration.name();
configurationDeclarer = declarer.withConfig(configName);
} else {
configurationDeclarer = declarer.withConfig(DEFAULT_CONFIG_NAME).describedAs(DEFAULT_CONFIG_DESCRIPTION);
}
Class<?> extensionClass = extensionType.getDeclaringClass().orElse(Object.class);
Class<?> configClass = configType.getDeclaringClass().orElse(Object.class);
ClassLoader classLoader = extensionClass.getClassLoader() != null ? extensionClass.getClassLoader() : Thread.currentThread().getContextClassLoader();
TypeAwareConfigurationFactory typeAwareConfigurationFactory = new TypeAwareConfigurationFactory(configClass, classLoader);
configurationDeclarer.withModelProperty(new ConfigurationFactoryModelProperty(typeAwareConfigurationFactory)).withModelProperty(new ImplementingTypeModelProperty(configClass));
configurationDeclarer.withModelProperty(new ExtensionTypeDescriptorModelProperty(configType));
loader.parseExternalLibs(configType, configurationDeclarer);
ParameterDeclarationContext context = new ParameterDeclarationContext(CONFIGURATION, configurationDeclarer.getDeclaration());
loader.getFieldParametersLoader().declare(configurationDeclarer, configType.getParameters(), context);
getOperationLoaderDelegate().declareOperations(declarer, configurationDeclarer, configType);
getSourceModelLoaderDelegate().declareMessageSources(declarer, configurationDeclarer, configType);
getFunctionModelLoaderDelegate().declareFunctions(declarer, configurationDeclarer, configType);
getConnectionProviderModelLoaderDelegate().declareConnectionProviders(configurationDeclarer, configType);
}
use of org.mule.runtime.module.extension.internal.loader.utils.ParameterDeclarationContext in project mule by mulesoft.
the class ConnectionProviderModelLoaderDelegate method declareConnectionProvider.
private void declareConnectionProvider(HasConnectionProviderDeclarer declarer, ConnectionProviderElement providerType) {
ConnectionProviderDeclarer providerDeclarer = connectionProviderDeclarers.get(providerType);
if (providerDeclarer != null) {
declarer.withConnectionProvider(providerDeclarer);
return;
}
String name = providerType.getAlias();
String description = providerType.getDescription();
if (providerType.getName().equals(providerType.getAlias())) {
name = DEFAULT_CONNECTION_PROVIDER_NAME;
}
List<Type> providerGenerics = providerType.getInterfaceGenerics(ConnectionProvider.class);
if (providerGenerics.size() != 1) {
// TODO: MULE-9220: Add a syntax validator for this
throw new IllegalConnectionProviderModelDefinitionException(format("Connection provider class '%s' was expected to have 1 generic type " + "(for the connection type) but %d were found", providerType.getName(), providerGenerics.size()));
}
providerDeclarer = declarer.withConnectionProvider(name).describedAs(description);
ConnectionProviderDeclarer finalProviderDeclarer = providerDeclarer;
providerType.getDeclaringClass().ifPresent(clazz -> finalProviderDeclarer.withModelProperty(new ConnectionProviderFactoryModelProperty(new DefaultConnectionProviderFactory<>(clazz, getExtensionClassLoader()))).withModelProperty(new ImplementingTypeModelProperty(clazz)));
providerDeclarer.withModelProperty(new ConnectionTypeModelProperty(providerGenerics.get(0))).withModelProperty(new ExtensionTypeDescriptorModelProperty(providerType));
loader.parseExternalLibs(providerType, providerDeclarer);
ConnectionManagementType managementType = NONE;
if (providerType.isAssignableTo(PoolingConnectionProvider.class)) {
managementType = POOLING;
} else if (providerType.isAssignableTo(CachedConnectionProvider.class)) {
managementType = CACHED;
}
parseOAuthGrantType(providerType, providerDeclarer);
providerDeclarer.withConnectionManagementType(managementType);
providerDeclarer.supportsConnectivityTesting(!providerType.isAssignableTo(NoConnectivityTest.class));
connectionProviderDeclarers.put(providerType, providerDeclarer);
ParameterDeclarationContext context = new ParameterDeclarationContext(CONNECTION_PROVIDER, providerDeclarer.getDeclaration());
loader.getFieldParametersLoader().declare(providerDeclarer, providerType.getParameters(), context);
}
use of org.mule.runtime.module.extension.internal.loader.utils.ParameterDeclarationContext in project mule by mulesoft.
the class FunctionModelLoaderDelegate method declareFunctions.
void declareFunctions(ExtensionDeclarer extensionDeclarer, HasFunctionDeclarer declarer, FunctionContainerElement methodOwnerClass, List<FunctionElement> functions) {
for (FunctionElement function : functions) {
FunctionContainerElement functionOwner = methodOwnerClass != null ? methodOwnerClass : function.getEnclosingType();
checkIsNotAnExtension(functionOwner);
final Optional<ExtensionParameter> configParameter = loader.getConfigParameter(function);
if (configParameter.isPresent()) {
throw new IllegalModelDefinitionException(format("Function '%s' requires a config parameter, but that is not allowed. " + "Remove such parameter.", function.getName()));
}
HasFunctionDeclarer actualDeclarer = (HasFunctionDeclarer) loader.selectDeclarerBasedOnConfig(extensionDeclarer, (Declarer) declarer, configParameter, empty());
if (functionDeclarers.containsKey(function)) {
actualDeclarer.withFunction(functionDeclarers.get(function));
continue;
}
final FunctionDeclarer functionDeclarer = actualDeclarer.withFunction(function.getAlias());
function.getMethod().ifPresent(method -> {
functionDeclarer.withModelProperty(new ImplementingMethodModelProperty(method));
function.getDeclaringClass().ifPresent(clazz -> functionDeclarer.withModelProperty(new FunctionExecutorModelProperty(new ReflectiveFunctionExecutorFactory<>(clazz, method))));
});
functionDeclarer.withOutput().ofType(function.getReturnMetadataType());
ParameterDeclarationContext declarationContext = new ParameterDeclarationContext(FUNCTION, functionDeclarer.getDeclaration());
loader.getMethodParametersLoader().declare(functionDeclarer, function.getParameters(), declarationContext);
functionDeclarers.put(function, functionDeclarer);
}
}
use of org.mule.runtime.module.extension.internal.loader.utils.ParameterDeclarationContext in project mule by mulesoft.
the class OperationModelLoaderDelegate method declareOperations.
void declareOperations(ExtensionDeclarer extensionDeclarer, HasOperationDeclarer ownerDeclarer, OperationContainerElement methodOwnerClass, List<OperationElement> operations, boolean supportsConfig) {
for (OperationElement operationMethod : operations) {
OperationContainerElement methodOwner = operationMethod.getEnclosingType();
OperationContainerElement enclosingType = methodOwnerClass != null ? methodOwnerClass : methodOwner;
checkOperationIsNotAnExtension(methodOwner);
final Optional<ExtensionParameter> configParameter = loader.getConfigParameter(operationMethod);
final Optional<ExtensionParameter> connectionParameter = loader.getConnectionParameter(operationMethod);
if (isScope(operationMethod)) {
scopesDelegate.declareScope(extensionDeclarer, ownerDeclarer, enclosingType, operationMethod, configParameter, connectionParameter);
continue;
} else if (isRouter(operationMethod)) {
routersDelegate.declareRouter(extensionDeclarer, ownerDeclarer, enclosingType, operationMethod, configParameter, connectionParameter);
continue;
}
checkDefinition(!loader.isInvalidConfigSupport(supportsConfig, configParameter, connectionParameter), format("Operation '%s' is defined at the extension level but it requires a config. " + "Remove such parameter or move the operation to the proper config", operationMethod.getName()));
HasOperationDeclarer actualDeclarer = selectDeclarer(extensionDeclarer, (Declarer) ownerDeclarer, operationMethod, configParameter, connectionParameter);
if (operationDeclarers.containsKey(operationMethod)) {
actualDeclarer.withOperation(operationDeclarers.get(operationMethod));
continue;
}
final OperationDeclarer operationDeclarer = actualDeclarer.withOperation(operationMethod.getAlias());
operationDeclarer.withModelProperty(new ExtensionOperationDescriptorModelProperty(operationMethod));
Optional<Method> method = operationMethod.getMethod();
Optional<Class<?>> declaringClass = enclosingType.getDeclaringClass();
if (method.isPresent() && declaringClass.isPresent()) {
operationDeclarer.withModelProperty(new ImplementingMethodModelProperty(method.get())).withModelProperty(new ComponentExecutorModelProperty(new ReflectiveOperationExecutorFactory<>(declaringClass.get(), method.get())));
}
loader.addExceptionEnricher(operationMethod, operationDeclarer);
final List<ExtensionParameter> fieldParameters = methodOwner.getParameters();
processComponentConnectivity(operationDeclarer, operationMethod, operationMethod);
if (isNonBlocking(operationMethod)) {
processNonBlockingOperation(operationDeclarer, operationMethod, true);
} else {
processBlockingOperation(supportsConfig, operationMethod, operationDeclarer);
}
addExecutionType(operationDeclarer, operationMethod);
ParameterDeclarationContext declarationContext = new ParameterDeclarationContext(OPERATION, operationDeclarer.getDeclaration());
processMimeType(operationDeclarer, operationMethod);
declareParameters(operationDeclarer, operationMethod.getParameters(), fieldParameters, declarationContext);
operationDeclarers.put(operationMethod, operationDeclarer);
}
}
use of org.mule.runtime.module.extension.internal.loader.utils.ParameterDeclarationContext in project mule by mulesoft.
the class RouterModelLoaderDelegate method declareRouter.
void declareRouter(ExtensionDeclarer extensionDeclarer, HasOperationDeclarer ownerDeclarer, OperationContainerElement enclosingType, OperationElement routerMethod, Optional<ExtensionParameter> configParameter, Optional<ExtensionParameter> connectionParameter) {
checkDefinition(!configParameter.isPresent(), format("Scope '%s' requires a config, but that is not allowed, remove such parameter", routerMethod.getName()));
checkDefinition(!connectionParameter.isPresent(), format("Scope '%s' requires a connection, but that is not allowed, remove such parameter", routerMethod.getName()));
HasConstructDeclarer actualDeclarer = (HasConstructDeclarer) loader.selectDeclarerBasedOnConfig(extensionDeclarer, (Declarer) ownerDeclarer, configParameter, connectionParameter);
if (constructDeclarers.containsKey(routerMethod)) {
actualDeclarer.withConstruct(constructDeclarers.get(routerMethod));
return;
}
final ConstructDeclarer router = actualDeclarer.withConstruct(routerMethod.getAlias());
router.withModelProperty(new ExtensionOperationDescriptorModelProperty(routerMethod));
Optional<Method> method = routerMethod.getMethod();
Optional<Class<?>> declaringClass = enclosingType.getDeclaringClass();
if (method.isPresent() && declaringClass.isPresent()) {
router.withModelProperty(new ImplementingMethodModelProperty(method.get())).withModelProperty(new ComponentExecutorModelProperty(new ReflectiveOperationExecutorFactory<>(declaringClass.get(), method.get())));
}
processMimeType(router, routerMethod);
List<ExtensionParameter> callbackParameters = routerMethod.getParameters().stream().filter(p -> VALID_CALLBACK_PARAMETERS.stream().anyMatch(validType -> p.getType().isSameType(validType))).collect(toList());
List<ExtensionParameter> routes = routerMethod.getParameters().stream().filter(this::isRoute).collect(toList());
checkDefinition(!callbackParameters.isEmpty(), format("Router '%s' does not declare a parameter with one of the types '%s'. One is required.", routerMethod.getAlias(), VALID_CALLBACK_PARAMETERS));
checkDefinition(!routes.isEmpty(), format("Router '%s' does not declare a '%s' parameter. One is required.", routerMethod.getAlias(), Route.class.getSimpleName()));
checkDefinition(callbackParameters.size() <= 1, format("Router '%s' defines more than one CompletionCallback parameters. Only one is allowed", routerMethod.getAlias()));
checkDefinition(isVoid(routerMethod), format("Router '%s' is not declared in a void method.", routerMethod.getAlias()));
List<ExtensionParameter> nonRouteParameters = routerMethod.getParameters().stream().filter(p -> !isRoute(p) && !callbackParameters.contains(p)).collect(toList());
declareParameters(router, nonRouteParameters, routerMethod.getEnclosingType().getParameters(), new ParameterDeclarationContext(CONSTRUCT, router.getDeclaration()));
declareRoutes(router, routes);
}
Aggregations