use of org.mule.runtime.api.meta.model.declaration.fluent.Declarer 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.api.meta.model.declaration.fluent.Declarer 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);
}
use of org.mule.runtime.api.meta.model.declaration.fluent.Declarer in project mule by mulesoft.
the class ScopeModelLoaderDelegate method declareScope.
void declareScope(ExtensionDeclarer extensionDeclarer, HasOperationDeclarer ownerDeclarer, OperationContainerElement enclosingType, OperationElement scopeMethod, Optional<ExtensionParameter> configParameter, Optional<ExtensionParameter> connectionParameter) {
HasOperationDeclarer actualDeclarer = (HasOperationDeclarer) loader.selectDeclarerBasedOnConfig(extensionDeclarer, (Declarer) ownerDeclarer, configParameter, connectionParameter);
checkDefinition(!configParameter.isPresent(), format("Scope '%s' requires a config, but that is not allowed, remove such parameter", scopeMethod.getName()));
checkDefinition(!connectionParameter.isPresent(), format("Scope '%s' requires a connection, but that is not allowed, remove such parameter", scopeMethod.getName()));
checkDefinition(isNonBlocking(scopeMethod), format("Scope '%s' does not declare a '%s' parameter. One is required for all operations " + "that receive and execute a Chain of other components", scopeMethod.getAlias(), CompletionCallback.class.getSimpleName()));
if (operationDeclarers.containsKey(scopeMethod)) {
actualDeclarer.withOperation(operationDeclarers.get(scopeMethod));
return;
}
final OperationDeclarer scope = actualDeclarer.withOperation(scopeMethod.getAlias());
scope.withModelProperty(new ExtensionOperationDescriptorModelProperty(scopeMethod));
Optional<Method> method = scopeMethod.getMethod();
Optional<Class<?>> declaringClass = enclosingType.getDeclaringClass();
if (method.isPresent() && declaringClass.isPresent()) {
scope.withModelProperty(new ImplementingMethodModelProperty(method.get())).withModelProperty(new ComponentExecutorModelProperty(new ReflectiveOperationExecutorFactory<>(declaringClass.get(), method.get())));
}
processMimeType(scope, scopeMethod);
processNonBlockingOperation(scope, scopeMethod, false);
List<ExtensionParameter> processorChain = scopeMethod.getParameters().stream().filter(ModelLoaderUtils::isProcessorChain).collect(toList());
checkDefinition(processorChain.size() <= 1, format("Scope '%s' declares too many parameters of type '%s', only one input of this kind is supported." + "Offending parameters are: %s", scopeMethod.getAlias(), Chain.class.getSimpleName(), processorChain.stream().map(ExtensionParameter::getName).collect(toList())));
declareParameters(scope, scopeMethod.getParameters(), scopeMethod.getEnclosingType().getParameters(), new ParameterDeclarationContext(SCOPE, scope.getDeclaration()));
loader.addExceptionEnricher(scopeMethod, scope);
operationDeclarers.put(scopeMethod, scope);
}
use of org.mule.runtime.api.meta.model.declaration.fluent.Declarer in project mule by mulesoft.
the class SourceModelLoaderDelegate method declareMessageSource.
void declareMessageSource(ExtensionDeclarer extensionDeclarer, HasSourceDeclarer declarer, SourceElement sourceType, boolean supportsConfig) {
// TODO: MULE-9220 - Add a syntax validator which checks that the sourceType doesn't implement
if (isLifecycle(sourceType)) {
throw new IllegalSourceModelDefinitionException(format("Source class '%s' implements a lifecycle interface. Sources are not allowed to", sourceType.getName()));
}
final Optional<ExtensionParameter> configParameter = loader.getConfigParameter(sourceType);
final Optional<ExtensionParameter> connectionParameter = loader.getConnectionParameter(sourceType);
if (loader.isInvalidConfigSupport(supportsConfig, configParameter, connectionParameter)) {
throw new IllegalSourceModelDefinitionException(format("Source '%s' is defined at the extension level but it requires a config parameter. " + "Remove such parameter or move the source to the proper config", sourceType.getName()));
}
HasSourceDeclarer actualDeclarer = (HasSourceDeclarer) loader.selectDeclarerBasedOnConfig(extensionDeclarer, (Declarer) declarer, configParameter, connectionParameter);
SourceDeclarer existingDeclarer = sourceDeclarers.get(sourceType);
if (existingDeclarer != null) {
actualDeclarer.withMessageSource(existingDeclarer);
return;
}
SourceDeclarer sourceDeclarer = actualDeclarer.withMessageSource(sourceType.getAlias());
sourceDeclarer.withModelProperty(new ExtensionTypeDescriptorModelProperty(sourceType));
List<Type> sourceGenerics = sourceType.getSuperClassGenerics();
if (sourceGenerics.size() != 2) {
// TODO: MULE-9220: Add a syntax validator for this
throw new IllegalModelDefinitionException(format("Message source class '%s' was expected to have 2 generic types " + "(one for the Payload type and another for the Attributes type) but %d were found", sourceType.getName(), sourceGenerics.size()));
}
sourceDeclarer.hasResponse(sourceType.isAnnotatedWith(EmitsResponse.class)).requiresConnection(connectionParameter.isPresent());
sourceType.getDeclaringClass().ifPresent(clazz -> sourceDeclarer.withModelProperty(new SourceFactoryModelProperty(new DefaultSourceFactory((Class<? extends Source>) clazz))).withModelProperty(new ImplementingTypeModelProperty(clazz)));
processMimeType(sourceDeclarer, sourceType);
processComponentConnectivity(sourceDeclarer, sourceType, sourceType);
resolveOutputTypes(sourceDeclarer, sourceType);
loader.addExceptionEnricher(sourceType, sourceDeclarer);
declareSourceParameters(sourceType, sourceDeclarer);
declareSourceCallback(sourceType, sourceDeclarer);
sourceDeclarers.put(sourceType, sourceDeclarer);
}
use of org.mule.runtime.api.meta.model.declaration.fluent.Declarer in project mule by mulesoft.
the class ParameterModelsLoaderDelegate method declaredAsGroup.
private List<ParameterDeclarer> declaredAsGroup(HasParametersDeclarer component, ParameterDeclarationContext declarationContext, ExtensionParameter groupParameter) throws IllegalParameterModelDefinitionException {
ParameterGroup groupAnnotation = groupParameter.getAnnotation(ParameterGroup.class).orElse(null);
if (groupAnnotation == null) {
return emptyList();
}
final String groupName = groupAnnotation.name();
if (DEFAULT_GROUP_NAME.equals(groupName)) {
throw new IllegalParameterModelDefinitionException(format("%s '%s' defines parameter group of name '%s' which is the default one. " + "@%s cannot be used with the default group name", getComponentDeclarationTypeName(((Declarer) component).getDeclaration()), ((NamedDeclaration) ((Declarer) component).getDeclaration()).getName(), groupName, ParameterGroup.class.getSimpleName()));
}
final Type type = groupParameter.getType();
final List<FieldElement> nestedGroups = type.getAnnotatedFields(ParameterGroup.class);
if (!nestedGroups.isEmpty()) {
throw new IllegalParameterModelDefinitionException(format("Class '%s' is used as a @%s but contains fields which also hold that annotation. Nesting groups is not allowed. " + "Offending fields are: [%s]", type.getName(), ParameterGroup.class.getSimpleName(), nestedGroups.stream().map(element -> element.getName()).collect(joining(","))));
}
if (groupParameter.isAnnotatedWith(org.mule.runtime.extension.api.annotation.param.Optional.class)) {
throw new IllegalParameterModelDefinitionException(format("@%s can not be applied alongside with @%s. Affected parameter is [%s].", org.mule.runtime.extension.api.annotation.param.Optional.class.getSimpleName(), ParameterGroup.class.getSimpleName(), groupParameter.getName()));
}
ParameterGroupDeclarer declarer = component.onParameterGroup(groupName);
if (declarer.getDeclaration().getModelProperty(ParameterGroupModelProperty.class).isPresent()) {
throw new IllegalParameterModelDefinitionException(format("Parameter group '%s' has already been declared on %s '%s'", groupName, getComponentDeclarationTypeName(((Declarer) component).getDeclaration()), ((NamedDeclaration) ((Declarer) component).getDeclaration()).getName()));
} else {
declarer.withModelProperty(new ParameterGroupModelProperty(new ParameterGroupDescriptor(groupName, type, groupParameter.getType().asMetadataType(), // TODO: Eliminate dependency to Annotated Elements
groupParameter.getDeclaringElement().orElse(null), groupParameter)));
}
final List<FieldElement> annotatedParameters = type.getAnnotatedFields(Parameter.class);
type.getAnnotation(ExclusiveOptionals.class).ifPresent(annotation -> {
Set<String> optionalParamNames = annotatedParameters.stream().filter(f -> !f.isRequired()).map(WithAlias::getAlias).collect(toSet());
declarer.withExclusiveOptionals(optionalParamNames, annotation.isOneRequired());
});
declarer.withDslInlineRepresentation(groupAnnotation.showInDsl());
groupParameter.getAnnotation(DisplayName.class).ifPresent(displayName -> declarer.withDisplayModel(DisplayModel.builder().displayName(displayName.value()).build()));
parseLayoutAnnotations(groupParameter, LayoutModel.builder()).ifPresent(declarer::withLayout);
declarer.withModelProperty(new ExtensionParameterDescriptorModelProperty(groupParameter));
if (!annotatedParameters.isEmpty()) {
return declare(component, annotatedParameters, declarationContext, declarer);
} else {
return declare(component, getFieldsWithGetters(type), declarationContext, declarer);
}
}
Aggregations