@Before public void before() throws MuleException { Error mockError = mock(Error.class); when(mockError.getErrorType()).thenReturn(mockErrorType); event = getEventBuilder().message(Message.of("")).error(mockError).build(); mockException = new MessagingException(event, new Exception()); when(mockTestExceptionStrategy2.accept(any(CoreEvent.class))).thenReturn(true); }
@Override public CoreEvent process(CoreEvent event) throws MuleException { try { Message msg; Error error = null; String payload = ((InternalEvent) event).getMessageAsString(muleContext); if (payload.indexOf(rejectIfMatches) >= 0) { throw new DefaultMuleException("Saw " + rejectIfMatches); } else if (payload.toLowerCase().indexOf(rejectIfMatches) >= 0) { Exception exception = new Exception(); error = createErrorMock(exception); msg = InternalMessage.builder().nullValue().exceptionPayload(new DefaultExceptionPayload(exception)).build(); } else { msg = of("No " + rejectIfMatches); } CoreEvent muleEvent = eventBuilder(muleContext).message(msg).error(error).build(); return muleEvent; } catch (Exception e) { throw new DefaultMuleException(e); } } }
@Before public void before() throws MuleException { Error mockError = mock(Error.class); when(mockError.getErrorType()).thenReturn(mockErrorType); event = getEventBuilder().message(Message.of("")).error(mockError).build(); mockException = new MessagingException(event, new Exception()); CoreEvent handledEvent = testEvent(); when(mockTestExceptionStrategy1.accept(any(CoreEvent.class))).thenReturn(true); when(mockTestExceptionStrategy1.apply(any(MessagingException.class))).thenReturn(just(handledEvent)); when(mockTestExceptionStrategy2.accept(any(CoreEvent.class))).thenReturn(true); when(mockTestExceptionStrategy2.apply(any(MessagingException.class))).thenReturn(just(handledEvent)); }
CoreEvent event = CoreEvent.builder(me.getEvent()).error(error).build();
.error(ErrorBuilder.builder().errorType(overloadErrorType) .description(format("Flow '%s' Busy.", getName())) .detailedDescription(format(BACK_PRESSURE_ERROR_MESSAGE, getName()))
CoreEvent event = CoreEvent.builder(PrivilegedEvent.getCurrentEvent().getContext()) .variables(incomingVariables) .error(incomingError) .message(message) .build();
@Override public final CompletableFuture<Event> execute(Event event) { CoreEvent internalEvent; BaseEventContext child = createChildEventContext(event.getContext()); if (event instanceof CoreEvent) { internalEvent = builder(child, (CoreEvent) event).build(); } else { internalEvent = CoreEvent.builder(createEventContext(null)) .message(event.getMessage()) .error(event.getError().orElse(null)) .variables(event.getVariables()) .build(); } return from(MessageProcessors.process(internalEvent, getExecutableFunction())) .onErrorMap(throwable -> { MessagingException messagingException = (MessagingException) throwable; CoreEvent messagingExceptionEvent = messagingException.getEvent(); return new ComponentExecutionException(messagingExceptionEvent.getError().get().getCause(), messagingExceptionEvent); }) .map(r -> builder(event.getContext(), r).build()) .cast(Event.class) .toFuture(); }
/** * Create new {@link CoreEvent} with {@link org.mule.runtime.api.message.Error} instance set. * * @param currentEvent event when error occured. * @param obj message processor/source. * @param me messaging exception. * @param locator the mule context. * @return new {@link CoreEvent} with relevant {@link org.mule.runtime.api.message.Error} set. */ public static CoreEvent createErrorEvent(CoreEvent currentEvent, Component obj, MessagingException me, ErrorTypeLocator locator) { Throwable cause = me.getCause() != null ? me.getCause() : me; List<ErrorMapping> errorMappings = getErrorMappings(obj); if (!errorMappings.isEmpty() || isMessagingExceptionCause(me, cause)) { Error newError = getErrorFromFailingProcessor(currentEvent, obj, cause, locator); CoreEvent newEvent = CoreEvent.builder(me.getEvent()).error(newError).build(); me.setProcessedEvent(newEvent); return newEvent; } else { return currentEvent; } }
/** * Unlike other {@link MessageProcessorChain MessageProcessorChains}, modules could contain error mappings that need to be * considered when resolving exceptions. */ private MessagingException handleSubChainException(MessagingException messagingException, CoreEvent originalRequest) { final CoreEvent.Builder builder = CoreEvent.builder(originalRequest).error(messagingException.getEvent().getError().get()); List<ErrorMapping> errorMappings = getErrorMappings(this); if (!errorMappings.isEmpty()) { Error error = messagingException.getEvent().getError().get(); ErrorType errorType = error.getErrorType(); ErrorType resolvedType = errorMappings.stream() .filter(m -> m.match(errorType)) .findFirst() .map(ErrorMapping::getTarget) .orElse(errorType); if (!resolvedType.equals(errorType)) { builder.error(ErrorBuilder.builder(error).errorType(resolvedType).build()); } } messagingException.setProcessedEvent(builder.build()); return messagingException; }
@Override public CoreEvent process(CoreEvent event) throws MuleException { try { Message msg; Error error = null; String payload = ((InternalEvent) event).getMessageAsString(muleContext); if (payload.indexOf(rejectIfMatches) >= 0) { throw new DefaultMuleException("Saw " + rejectIfMatches); } else if (payload.toLowerCase().indexOf(rejectIfMatches) >= 0) { Exception exception = new Exception(); error = createErrorMock(exception); msg = InternalMessage.builder().nullValue().exceptionPayload(new DefaultExceptionPayload(exception)).build(); } else { msg = of("No " + rejectIfMatches); } CoreEvent muleEvent = eventBuilder(muleContext).message(msg).error(error).build(); return muleEvent; } catch (Exception e) { throw new DefaultMuleException(e); } } }
@Override public final CompletableFuture<ExecutionResult> execute(InputEvent inputEvent) { CompletableFuture completableFuture = new CompletableFuture(); CoreEvent.Builder builder = CoreEvent.builder(createEventContext(of(completableFuture))); CoreEvent event = builder.message(inputEvent.getMessage()) .error(inputEvent.getError().orElse(null)) .variables(inputEvent.getVariables()) .build(); return from(MessageProcessors.process(event, getExecutableFunction())) .onErrorMap(throwable -> { MessagingException messagingException = (MessagingException) throwable; CoreEvent messagingExceptionEvent = messagingException.getEvent(); return new ComponentExecutionException(messagingExceptionEvent.getError().get().getCause(), messagingExceptionEvent); }) .<ExecutionResult>map(result -> new ExecutionResultImplementation(result, completableFuture)) .toFuture(); }
private Mono<Void> sendErrorResponse(MessagingException messagingException, Function<CoreEvent, Map<String, Object>> errorParameters, final PhaseContext ctx, FlowConstruct flowConstruct) { CoreEvent event = messagingException.getEvent(); if (messagingException.inErrorHandler()) { return error(new SourceErrorException(event, sourceErrorResponseGenerateErrorType, messagingException.getCause(), messagingException)); } else { try { return from(ctx.template .sendFailureResponseToClient(messagingException, errorParameters.apply(event))) .onErrorMap(e -> new SourceErrorException(builder(messagingException.getEvent()) .error(builder(e).errorType(sourceErrorResponseSendErrorType).build()).build(), sourceErrorResponseSendErrorType, e)); } catch (Exception e) { return error(new SourceErrorException(event, sourceErrorResponseGenerateErrorType, e, messagingException)); } } }
private static CoreEvent eventWithError(CoreEvent event, TypedException cause) { return CoreEvent.builder(event) .error(ErrorBuilder.builder(cause.getCause()).errorType(cause.getErrorType()).build()).build(); }
private MessagingException buildFailingFlowException(final CoreEvent event, final Exception exception) { return new MessagingException(CoreEvent.builder(event) .error(ErrorBuilder.builder(exception).errorType(ERROR_FROM_FLOW).build()) .build(), exception); }
protected CoreEvent nullifyExceptionPayloadIfRequired(CoreEvent event) { if (this.handleException) { return CoreEvent.builder(event).error(null) .message(InternalMessage.builder(event.getMessage()).exceptionPayload(null).build()) .build(); } else { return event; } }
private CoreEvent createTimeoutErrorEvent(ErrorType timeoutErrorType, RoutingPair pair) { return builder(pair.getEvent()).message(Message.of(null)) .error(ErrorBuilder.builder().errorType(timeoutErrorType) .exception(new TimeoutException()).description(TIMEOUT_EXCEPTION_DESCRIPTION) .detailedDescription(TIMEOUT_EXCEPTION_DETAILED_DESCRIPTION_PREFIX + " '" + pair.getEvent().getGroupCorrelation().get().getSequence() + "'") .build()) .build(); }
public MessagingException toMessagingException(Collection<ExceptionContextProvider> exceptionContextProviders, MessageSource messageSource) { MessagingException messagingException = new MessagingException(CoreEvent.builder(getEvent()) .error(ErrorBuilder.builder(getCause()) .errorType(getErrorType()) .build()) .build(), getCause()); EnrichedNotificationInfo notificationInfo = createInfo(messagingException.getEvent(), messagingException, null); exceptionContextProviders.forEach(cp -> { cp.getContextInfo(notificationInfo, messageSource).forEach((k, v) -> messagingException.getInfo().putIfAbsent(k, v)); }); return messagingException; }
@Override protected CoreEvent nullifyExceptionPayloadIfRequired(CoreEvent event) { return CoreEvent.builder(event).error(null) .message(InternalMessage.builder(event.getMessage()).exceptionPayload(null).build()) .build(); }
@Override public CoreEvent process(CoreEvent event) throws MuleException { CoreEvent copy; if (attributeEvaluator == null) { copy = CoreEvent.builder(event) // Queue works based on MuleEvent for testing purposes. A real operation // would not be aware of the error field and just the plain message would be sent. .error(null) .build(); } else { Object payloadValue = attributeEvaluator.resolveTypedValue(event).getValue(); copy = CoreEvent.builder(event).message(Message.builder(event.getMessage()).value(payloadValue).build()) // Queue works based on MuleEvent for testing purposes. A real operation // would not be aware of the error field and just the plain message would be sent. .error(null) .build(); } queueHandler.write(name, copy); return event; }
private MessagingException buildFailingFlowException(final CoreEvent event, final Exception exception) { return new MessagingException(CoreEvent.builder(event) .error(ErrorBuilder.builder(exception).errorType(ERROR_FROM_FLOW).build()) .build(), exception); }