/** * A shortcut factory method for creating a message with the given payload * and {@code MessageHeaders}. * <p><strong>Note:</strong> the given {@code MessageHeaders} instance is used * directly in the new message, i.e. it is not copied. * @param payload the payload to use (never {@code null}) * @param messageHeaders the headers to use (never {@code null}) * @return the created message * @since 4.1 */ @SuppressWarnings("unchecked") public static <T> Message<T> createMessage(@Nullable T payload, MessageHeaders messageHeaders) { Assert.notNull(payload, "Payload must not be null"); Assert.notNull(messageHeaders, "MessageHeaders must not be null"); if (payload instanceof Throwable) { return (Message<T>) new ErrorMessage((Throwable) payload, messageHeaders); } else { return new GenericMessage<>(payload, messageHeaders); } }
@Transformer public Message<?> transform(ErrorMessage errorMessage) { return ((MessagingException) errorMessage.getPayload()).getFailedMessage(); }
@Test public void testToString() { ErrorMessage em = new ErrorMessage(new RuntimeException("foo")); String emString = em.toString(); assertThat(emString, not(containsString("original"))); em = new ErrorMessage(new RuntimeException("foo"), new GenericMessage<>("bar")); emString = em.toString(); assertThat(emString, containsString("original")); assertThat(emString, containsString(em.getOriginalMessage().toString())); }
IntegrationMessageHeaderAccessor headerAccessor = new IntegrationMessageHeaderAccessor(message); headerAccessor.setHeader(HEADER_NAME, history); Throwable payload = ((ErrorMessage) message).getPayload(); ErrorMessage errorMessage = new ErrorMessage(payload, headerAccessor.toMessageHeaders()); message = (Message<T>) errorMessage;
Message<?> mutableMessage = new MutableMessage<>(UUID.randomUUID()); Message<?> adviceMessage = new AdviceMessage<>("foo", genericMessage); ErrorMessage errorMessage = new ErrorMessage(new RuntimeException("test exception"), mutableMessage); assertEquals(adviceMessage, messages.get(2)); Message<?> errorMessageResult = messages.get(3); assertEquals(errorMessage.getHeaders(), errorMessageResult.getHeaders()); assertThat(errorMessageResult, instanceOf(ErrorMessage.class)); assertEquals(errorMessage.getOriginalMessage(), ((ErrorMessage) errorMessageResult).getOriginalMessage()); assertEquals(errorMessage.getPayload().getMessage(), ((ErrorMessage) errorMessageResult).getPayload().getMessage());
@Override public ErrorMessage convert(Document source) { @SuppressWarnings("unchecked") Map<String, Object> headers = MongoDbMessageStore.this.converter.normalizeHeaders((Map<String, Object>) source.get("headers")); Object payload = this.deserializingConverter.convert(((Binary) source.get("payload")).getData()); ErrorMessage message = new ErrorMessage((Throwable) payload, headers); // NOSONAR not null enhanceHeaders(message.getHeaders(), headers); return message; }
@Test public void enhancedRecoverer() { QueueChannel channel = new QueueChannel(); ErrorMessageSendingRecoverer recoverer = new ErrorMessageSendingRecoverer(channel); recoverer.publish(new GenericMessage<>("foo"), new GenericMessage<>("bar"), new RuntimeException("baz")); Message<?> error = channel.receive(0); assertThat(error, instanceOf(ErrorMessage.class)); assertThat(error.getPayload(), instanceOf(MessagingException.class)); MessagingException payload = (MessagingException) error.getPayload(); assertThat(payload.getCause(), instanceOf(RuntimeException.class)); assertThat(payload.getCause().getMessage(), equalTo("baz")); assertThat(payload.getFailedMessage().getPayload(), equalTo("bar")); assertThat(((ErrorMessage) error).getOriginalMessage().getPayload(), equalTo("foo")); }
@Test public void testCorrectErrorMessageAfterWrite() { RuntimeException payload = new RuntimeException(); ErrorMessage original = new ErrorMessage(payload); assertNull(MessageHistory.read(original)); Message<Throwable> result1 = MessageHistory.write(original, new TestComponent(1)); assertThat(result1, instanceOf(ErrorMessage.class)); assertNotSame(original, result1); assertSame(original.getPayload(), result1.getPayload()); MessageHistory history1 = MessageHistory.read(result1); assertNotNull(history1); assertEquals("testComponent-1", history1.toString()); Message<Throwable> result2 = MessageHistory.write(result1, new TestComponent(2)); assertThat(result2, instanceOf(ErrorMessage.class)); assertNotSame(original, result2); assertNotSame(result1, result2); assertSame(original.getPayload(), result2.getPayload()); MessageHistory history2 = MessageHistory.read(result2); assertNotNull(history2); assertEquals("testComponent-1,testComponent-2", history2.toString()); }
@Override public ErrorMessage convert(Document source) { @SuppressWarnings("unchecked") Map<String, Object> headers = MongoDbMessageStore.this.converter.normalizeHeaders((Map<String, Object>) source.get("headers")); Object payload = this.deserializingConverter.convert(((Binary) source.get("payload")).getData()); ErrorMessage message = new ErrorMessage((Throwable) payload, headers); // NOSONAR not null enhanceHeaders(message.getHeaders(), headers); return message; }
/** * MessagingTemplate sets the errorChannel to the replyChannel so it gets any async * exceptions via the default {@link MessagePublishingErrorHandler}. */ @Test public void testReplaceError() { MessagingTemplate template = new MessagingTemplate(); template.setDefaultDestination(this.inputPolled); Message<?> reply = template.sendAndReceive(new GenericMessage<String>("bar")); assertNotNull(reply); assertTrue(reply instanceof ErrorMessage); assertNotNull(((ErrorMessage) reply).getOriginalMessage()); assertThat(reply.getPayload(), not(instanceOf(MessagingExceptionWrapper.class))); }
@SuppressWarnings("unchecked") public Message<T> build() { if (this.originalMessage != null && !this.headerAccessor.isModified()) { return this.originalMessage; } MessageHeaders headersToUse = this.headerAccessor.toMessageHeaders(); if (this.payload instanceof Throwable) { return (Message<T>) new ErrorMessage((Throwable) this.payload, headersToUse); } else { return new GenericMessage<>(this.payload, headersToUse); } }
protected void convertAndSend(Message<?> message) { try { if (message instanceof ErrorMessage) { if (this.logger.isDebugEnabled()) { this.logger.debug("Error on syslog socket:" + ((ErrorMessage) message).getPayload().getMessage()); } } else { this.sendMessage(this.converter.fromSyslog(message)); } } catch (Exception e) { throw new MessagingException(message, "Failed to send Message", e); } }
IntegrationMessageHeaderAccessor headerAccessor = new IntegrationMessageHeaderAccessor(message); headerAccessor.setHeader(HEADER_NAME, history); Throwable payload = ((ErrorMessage) message).getPayload(); ErrorMessage errorMessage = new ErrorMessage(payload, headerAccessor.toMessageHeaders()); message = (Message<T>) errorMessage;
MessageHeaders headers = received.getHeaders(); assertThat(headers.get(KafkaHeaders.RAW_DATA)).isNotNull(); received = ((ErrorMessage) received).getOriginalMessage(); assertThat(received).isNotNull(); headers = received.getHeaders();
@Test public void resolveMessageSubclassMatch() throws Exception { ErrorMessage message = new ErrorMessage(new UnsupportedOperationException()); MethodParameter parameter = new MethodParameter(this.method, 4); assertTrue(this.resolver.supportsParameter(parameter)); assertSame(message, this.resolver.resolveArgument(parameter, message)); }
/** * Publish an error message for the supplied throwable and context. * The {@link #errorMessageStrategy} is used to build a {@link ErrorMessage} * to publish. * @param throwable the throwable. May be null. * @param context the context for {@link ErrorMessage} properties. */ public void publish(Throwable throwable, AttributeAccessor context) { populateChannel(); Throwable payload = determinePayload(throwable, context); ErrorMessage errorMessage = this.errorMessageStrategy.buildErrorMessage(payload, context); if (this.logger.isDebugEnabled() && payload instanceof MessagingException) { MessagingException exception = (MessagingException) errorMessage.getPayload(); this.logger.debug("Sending ErrorMessage: failedMessage: " + exception.getFailedMessage(), exception); } this.messagingTemplate.send(errorMessage); }
MessageHeaders headers = received.getHeaders(); assertThat(headers.get(KafkaHeaders.RAW_DATA)).isNotNull(); received = ((ErrorMessage) received).getOriginalMessage(); assertThat(received).isNotNull(); headers = received.getHeaders();
@Test public void resolveWithMessageSubclassAndPayloadWildcard() throws Exception { ErrorMessage message = new ErrorMessage(new UnsupportedOperationException()); MethodParameter parameter = new MethodParameter(this.method, 0); assertTrue(this.resolver.supportsParameter(parameter)); assertSame(message, this.resolver.resolveArgument(parameter, message)); }
errorMessageRef.set(((ErrorMessage) message).getPayload()); errorMessageLetch.countDown();
private Message<?> outputMessage(Message<?> originalMessage, Message<?> retrievedMessage, MessageHeaderAccessor additionalHeaders) { MessageHeaderAccessor headers = MessageHeaderAccessor .getMutableAccessor(originalMessage); if (originalMessage.getPayload() instanceof MessagingException) { headers.copyHeaders(MessageHeaderPropagation.propagationHeaders( additionalHeaders.getMessageHeaders(), this.tracing.propagation().keys())); return new ErrorMessage((MessagingException) originalMessage.getPayload(), isWebSockets(headers) ? headers.getMessageHeaders() : new MessageHeaders(headers.getMessageHeaders())); } headers.copyHeaders(additionalHeaders.getMessageHeaders()); return new GenericMessage<>(retrievedMessage.getPayload(), isWebSockets(headers) ? headers.getMessageHeaders() : new MessageHeaders(headers.getMessageHeaders())); }