@Transformer public Message<?> transform(ErrorMessage errorMessage) { return ((MessagingException) errorMessage.getPayload()).getFailedMessage(); }
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); } }
/** * 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); }
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;
errorMessageRef.set(((ErrorMessage) message).getPayload()); errorMessageLetch.countDown();
errorMessageRef.set(((ErrorMessage) message).getPayload()); errorMessageLetch.countDown();
if (!error && replyMessage instanceof ErrorMessage) { ErrorMessage em = (ErrorMessage) replyMessage; if (em.getPayload() instanceof MessagingException) { throw (MessagingException) em.getPayload(); throw new MessagingException(requestMessage, em.getPayload());
errorMessageRef.set(((ErrorMessage) message).getPayload()); errorMessageLetch.countDown();
errorMessageRef.set(((ErrorMessage) message).getPayload()); errorMessageLetch.countDown();
errorMessageRef.set(((ErrorMessage) message).getPayload()); errorMessageLetch.countDown();
errorMessageRef.set(((ErrorMessage) message).getPayload()); errorMessageLetch.countDown();
@Test public void testBadConversion() throws Exception { final QueueChannel requestChannel = new QueueChannel(); ChannelPublishingJmsMessageListener listener = new ChannelPublishingJmsMessageListener(); Log logger = spy(TestUtils.getPropertyValue(listener, "logger", Log.class)); doNothing().when(logger).error(anyString(), any(Throwable.class)); new DirectFieldAccessor(listener).setPropertyValue("logger", logger); listener.setRequestChannel(requestChannel); QueueChannel errorChannel = new QueueChannel(); listener.setErrorChannel(errorChannel); listener.setBeanFactory(mock(BeanFactory.class)); listener.setMessageConverter(new TestMessageConverter() { @Override public Object fromMessage(javax.jms.Message message) throws JMSException, MessageConversionException { return null; } }); listener.afterPropertiesSet(); javax.jms.Message jmsMessage = session.createTextMessage("test"); listener.onMessage(jmsMessage, mock(Session.class)); ErrorMessage received = (ErrorMessage) errorChannel.receive(0); assertNotNull(received); assertThat(received.getPayload().getMessage(), startsWith("Inbound conversion failed")); listener.stop(); }
@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()); }
@Test public void testZeroGroupTimeoutExpressionScheduling() { try { this.output.purge(null); this.errors.purge(null); GenericMessage<String> message = new GenericMessage<>("foo"); this.output.send(message); this.output.send(message); this.output.send(message); this.output.send(message); this.output.send(message); this.zeroGroupTimeoutExpressionAggregatorInput.send(new GenericMessage<>(1, stubHeaders(1, 2, 1))); ErrorMessage em = (ErrorMessage) this.errors.receive(10000); assertNotNull(em); assertThat(em.getPayload().getMessage().toLowerCase(), containsString("failed to send message to channel 'output' within timeout: 10")); } finally { this.output.purge(null); this.errors.purge(null); } }
assertThat(errorMessageResult, instanceOf(ErrorMessage.class)); assertEquals(errorMessage.getOriginalMessage(), ((ErrorMessage) errorMessageResult).getOriginalMessage()); assertEquals(errorMessage.getPayload().getMessage(), ((ErrorMessage) errorMessageResult).getPayload().getMessage());
/** * Verify that Errors such as OOM are properly propagated and we suppress the * ThrowableHolderException from the output message. */ @Test public void throwableProperlyPropagatedAndReported() { QueueChannel errors = new QueueChannel(); ExpressionEvaluatingRequestHandlerAdvice expressionAdvice = new ExpressionEvaluatingRequestHandlerAdvice(); expressionAdvice.setBeanFactory(mock(BeanFactory.class)); expressionAdvice.setOnFailureExpressionString("'foo'"); expressionAdvice.setFailureChannel(errors); Throwable theThrowable = new Throwable("foo"); ProxyFactory proxyFactory = new ProxyFactory(new Foo(theThrowable)); proxyFactory.addAdvice(expressionAdvice); Bar fooHandler = (Bar) proxyFactory.getProxy(); try { fooHandler.handleRequestMessage(new GenericMessage<>("foo")); fail("Expected throwable"); } catch (Throwable t) { assertSame(theThrowable, t); ErrorMessage error = (ErrorMessage) errors.receive(10000); assertNotNull(error); assertSame(theThrowable, error.getPayload().getCause()); } }
@Test public void validateSuccessfulErrorFlowDoesNotThrowErrors() { this.context.refresh(); DirectChannel outChannel = new DirectChannel(); outChannel.subscribe(message -> { throw new RuntimeException("problems"); }); PublishSubscribeChannel errorChannel = new PublishSubscribeChannel(); SuccessfulErrorService errorService = new SuccessfulErrorService(); ServiceActivatingHandler handler = new ServiceActivatingHandler(errorService); handler.setBeanFactory(this.context); handler.afterPropertiesSet(); errorChannel.subscribe(handler); MessageProducerSupport mps = new MessageProducerSupport() { }; mps.setOutputChannel(outChannel); mps.setErrorChannel(errorChannel); mps.setBeanFactory(this.context); mps.afterPropertiesSet(); mps.start(); Message<?> message = new GenericMessage<>("hello"); mps.sendMessage(message); assertThat(errorService.lastMessage, instanceOf(ErrorMessage.class)); ErrorMessage errorMessage = (ErrorMessage) errorService.lastMessage; assertEquals(MessageDeliveryException.class, errorMessage.getPayload().getClass()); MessageDeliveryException exception = (MessageDeliveryException) errorMessage.getPayload(); assertEquals(message, exception.getFailedMessage()); }
@Test public void testWithErrorChannel() { DefaultListableBeanFactory bf = new DefaultListableBeanFactory(); XMPPConnection connection = mock(XMPPConnection.class); bf.registerSingleton(XmppContextUtils.XMPP_CONNECTION_BEAN_NAME, connection); PresenceListeningEndpoint endpoint = new PresenceListeningEndpoint(); DirectChannel outChannel = new DirectChannel(); outChannel.subscribe(message -> { throw new RuntimeException("ooops"); }); PollableChannel errorChannel = new QueueChannel(); endpoint.setBeanFactory(bf); endpoint.setOutputChannel(outChannel); endpoint.setErrorChannel(errorChannel); endpoint.afterPropertiesSet(); RosterListener listener = (RosterListener) TestUtils.getPropertyValue(endpoint, "rosterListener"); Presence presence = new Presence(Type.available); listener.presenceChanged(presence); ErrorMessage msg = (ErrorMessage) errorChannel.receive(); assertSame(presence, ((MessagingException) msg.getPayload()) .getFailedMessage() .getPayload()); }
@Test public void testWithErrorChannel() throws Exception { DefaultListableBeanFactory bf = new DefaultListableBeanFactory(); XMPPConnection connection = mock(XMPPConnection.class); bf.registerSingleton(XmppContextUtils.XMPP_CONNECTION_BEAN_NAME, connection); ChatMessageListeningEndpoint endpoint = new ChatMessageListeningEndpoint(); DirectChannel outChannel = new DirectChannel(); outChannel.subscribe(message -> { throw new RuntimeException("ooops"); }); PollableChannel errorChannel = new QueueChannel(); endpoint.setBeanFactory(bf); endpoint.setOutputChannel(outChannel); endpoint.setErrorChannel(errorChannel); endpoint.afterPropertiesSet(); StanzaListener listener = (StanzaListener) TestUtils.getPropertyValue(endpoint, "stanzaListener"); Message smackMessage = new Message(JidCreate.from("kermit@frog.com")); smackMessage.setBody("hello"); smackMessage.setThread("1234"); listener.processStanza(smackMessage); ErrorMessage msg = (ErrorMessage) errorChannel.receive(); assertEquals("hello", ((MessagingException) msg.getPayload()).getFailedMessage().getPayload()); }
@Test public void errorChannelWithFailedDispatch() throws InterruptedException { TestApplicationContext context = TestUtils.createTestApplicationContext(); QueueChannel errorChannel = new QueueChannel(); QueueChannel outputChannel = new QueueChannel(); context.registerChannel("errorChannel", errorChannel); CountDownLatch latch = new CountDownLatch(1); SourcePollingChannelAdapter channelAdapter = new SourcePollingChannelAdapter(); channelAdapter.setSource(new FailingSource(latch)); PollerMetadata pollerMetadata = new PollerMetadata(); pollerMetadata.setTrigger(new PeriodicTrigger(1000)); channelAdapter.setOutputChannel(outputChannel); context.registerEndpoint("testChannel", channelAdapter); context.refresh(); latch.await(2000, TimeUnit.MILLISECONDS); Message<?> message = errorChannel.receive(5000); context.close(); assertNull(outputChannel.receive(100)); assertNotNull("message should not be null", message); assertTrue(message instanceof ErrorMessage); Throwable exception = ((ErrorMessage) message).getPayload(); assertEquals("intentional test failure", exception.getCause().getMessage()); }