public final void setMessageStore(MessageGroupStore store) { this.messageStore = store; UniqueExpiryCallback expiryCallback = (messageGroupStore, group) -> this.forceReleaseProcessor.processMessageGroup(group); store.registerMessageGroupExpiryCallback(expiryCallback); }
private void processForceRelease(Object groupId, long timestamp, long lastModified) { MessageGroup messageGroup = this.messageStore.getMessageGroup(groupId); if (messageGroup.getTimestamp() == timestamp && messageGroup.getLastModified() == lastModified) { this.forceReleaseProcessor.processMessageGroup(messageGroup); } }
/** * Override to change the default mechanism by which the inbound and release messages * are returned as a result. * @param key The correlation key. * @param requestMessage the inbound message. * @param releaseMessage the release message. * @return the result. */ protected Object buildResult(Object key, Message<?> requestMessage, Message<?> releaseMessage) { SimpleMessageGroup group = new SimpleMessageGroup(key); group.add(requestMessage); group.add(releaseMessage); return this.messageGroupProcessor.processMessageGroup(group); }
this.forceReleaseProcessor.processMessageGroup(messageGroup);
result = this.outputProcessor.processMessageGroup(group); if (result instanceof Collection<?>) { verifyResultCollectionConsistsOfMessages((Collection<?>) result);
@Test public void bufferCompletesNormally() throws Exception { String correlationKey = "key"; Message<?> message1 = testMessage(correlationKey, 1, 2); Message<?> message2 = testMessage(correlationKey, 2, 2); when(correlationStrategy.getCorrelationKey(isA(Message.class))).thenReturn(correlationKey); when(processor.processMessageGroup(any(MessageGroup.class))).thenReturn(MessageBuilder.withPayload("grouped").build()); when(outputChannel.send(any(Message.class))).thenReturn(true); handler.handleMessage(message1); handler.handleMessage(message2); verify(correlationStrategy).getCorrelationKey(message1); verify(correlationStrategy).getCorrelationKey(message2); verify(processor).processMessageGroup(isA(SimpleMessageGroup.class)); }
@Test public void shouldNotPruneWhileCompleting() throws Exception { String correlationKey = "key"; final Message<?> message1 = testMessage(correlationKey, 1, 2); final Message<?> message2 = testMessage(correlationKey, 2, 2); final List<Message<?>> storedMessages = new ArrayList<Message<?>>(); final CountDownLatch bothMessagesHandled = new CountDownLatch(2); when(correlationStrategy.getCorrelationKey(isA(Message.class))).thenReturn(correlationKey); when(processor.processMessageGroup(any(MessageGroup.class))).thenReturn(MessageBuilder.withPayload("grouped").build()); when(outputChannel.send(any(Message.class))).thenReturn(true); handler.handleMessage(message1); bothMessagesHandled.countDown(); storedMessages.add(message1); ExecutorService exec = Executors.newSingleThreadExecutor(); exec.submit(() -> { handler.handleMessage(message2); storedMessages.add(message2); bothMessagesHandled.countDown(); }); assertTrue(bothMessagesHandled.await(10, TimeUnit.SECONDS)); assertEquals(0, store.expireMessageGroups(10000)); exec.shutdownNow(); }
private void singleMessage(MessageGroupProcessor processor) { Map<String, Object> headers = new HashMap<>(); headers.put("k1", "value1"); headers.put("k2", 2); Message<?> message = correlatedMessage(1, 1, 1, headers); List<Message<?>> messages = Collections.singletonList(message); MessageGroup group = new SimpleMessageGroup(messages, 1); Object result = processor.processMessageGroup(group); assertNotNull(result); assertTrue(result instanceof AbstractIntegrationMessageBuilder<?>); Message<?> resultMessage = ((AbstractIntegrationMessageBuilder<?>) result).build(); assertEquals("value1", resultMessage.getHeaders().get("k1")); assertEquals(2, resultMessage.getHeaders().get("k2")); }
private void twoMessagesWithConflicts(MessageGroupProcessor processor) { Map<String, Object> headers1 = new HashMap<>(); headers1.put("k1", "foo"); headers1.put("k2", 123); Message<?> message1 = correlatedMessage(1, 2, 1, headers1); Map<String, Object> headers2 = new HashMap<>(); headers2.put("k1", "bar"); headers2.put("k2", 123); Message<?> message2 = correlatedMessage(1, 2, 2, headers2); List<Message<?>> messages = Arrays.asList(message1, message2); MessageGroup group = new SimpleMessageGroup(messages, 1); Object result = processor.processMessageGroup(group); assertNotNull(result); assertTrue(result instanceof AbstractIntegrationMessageBuilder<?>); Message<?> resultMessage = ((AbstractIntegrationMessageBuilder<?>) result).build(); assertNull(resultMessage.getHeaders().get("k1")); assertEquals(123, resultMessage.getHeaders().get("k2")); }
private void multipleValuesConflict(MessageGroupProcessor processor) { Map<String, Object> headers1 = new HashMap<>(); headers1.put("common", "valueForAll"); headers1.put("conflict", "valueFor1"); Message<?> message1 = correlatedMessage(1, 3, 1, headers1); Map<String, Object> headers2 = new HashMap<>(); headers2.put("common", "valueForAll"); headers2.put("conflict", "valueFor2"); Message<?> message2 = correlatedMessage(1, 3, 2, headers2); Map<String, Object> headers3 = new HashMap<>(); headers3.put("conflict", "valueFor3"); headers3.put("common", "valueForAll"); Message<?> message3 = correlatedMessage(1, 3, 3, headers3); List<Message<?>> messages = Arrays.asList(message1, message2, message3); MessageGroup group = new SimpleMessageGroup(messages, 1); Object result = processor.processMessageGroup(group); assertNotNull(result); assertTrue(result instanceof AbstractIntegrationMessageBuilder<?>); Message<?> resultMessage = ((AbstractIntegrationMessageBuilder<?>) result).build(); assertEquals("valueForAll", resultMessage.getHeaders().get("common")); assertNull(resultMessage.getHeaders().get("conflict")); }
private void twoMessagesWithoutConflicts(MessageGroupProcessor processor) { Map<String, Object> headers = new HashMap<>(); headers.put("k1", "value1"); headers.put("k2", 2); Message<?> message1 = correlatedMessage(1, 2, 1, headers); Message<?> message2 = correlatedMessage(1, 2, 2, headers); List<Message<?>> messages = Arrays.asList(message1, message2); MessageGroup group = new SimpleMessageGroup(messages, 1); Object result = processor.processMessageGroup(group); assertNotNull(result); assertTrue(result instanceof AbstractIntegrationMessageBuilder<?>); Message<?> resultMessage = ((AbstractIntegrationMessageBuilder<?>) result).build(); assertEquals("value1", resultMessage.getHeaders().get("k1")); assertEquals(2, resultMessage.getHeaders().get("k2")); }
List<Message<?>> messages = Arrays.asList(message1, message2, message3); MessageGroup group = new SimpleMessageGroup(messages, 1); Object result = processor.processMessageGroup(group); assertNotNull(result); assertTrue(result instanceof AbstractIntegrationMessageBuilder<?>);
@Test public void bufferCompletesWithException() throws Exception { doAnswer(new ThrowsException(new RuntimeException("Planned test exception"))) .when(processor).processMessageGroup(isA(SimpleMessageGroup.class)); String correlationKey = "key"; Message<?> message1 = testMessage(correlationKey, 1, 2); Message<?> message2 = testMessage(correlationKey, 2, 2); when(correlationStrategy.getCorrelationKey(isA(Message.class))).thenReturn(correlationKey); handler.setExpireGroupsUponCompletion(true); handler.handleMessage(message1); try { handler.handleMessage(message2); fail("Expected MessageHandlingException"); } catch (MessageHandlingException e) { assertEquals(0, store.getMessageGroup(correlationKey).size()); } verify(correlationStrategy).getCorrelationKey(message1); verify(correlationStrategy).getCorrelationKey(message2); verify(processor).processMessageGroup(isA(SimpleMessageGroup.class)); }
@Override public Object processMessageGroup(MessageGroup group) { return this.delegate.processMessageGroup(group); }
@Override public Object processMessageGroup(MessageGroup group) { return this.delegate.processMessageGroup(group); }
public final void setMessageStore(MessageGroupStore store) { this.messageStore = store; UniqueExpiryCallback expiryCallback = (messageGroupStore, group) -> this.forceReleaseProcessor.processMessageGroup(group); store.registerMessageGroupExpiryCallback(expiryCallback); }
private void processForceRelease(Object groupId, long timestamp, long lastModified) { MessageGroup messageGroup = this.messageStore.getMessageGroup(groupId); if (messageGroup.getTimestamp() == timestamp && messageGroup.getLastModified() == lastModified) { this.forceReleaseProcessor.processMessageGroup(messageGroup); } }
/** * Override to change the default mechanism by which the inbound and release messages * are returned as a result. * @param key The correlation key. * @param requestMessage the inbound message. * @param releaseMessage the release message. * @return the result. */ protected Object buildResult(Object key, Message<?> requestMessage, Message<?> releaseMessage) { SimpleMessageGroup group = new SimpleMessageGroup(key); group.add(requestMessage); group.add(releaseMessage); return this.messageGroupProcessor.processMessageGroup(group); }
result = this.outputProcessor.processMessageGroup(group); if (result instanceof Collection<?>) { verifyResultCollectionConsistsOfMessages((Collection<?>) result);
this.forceReleaseProcessor.processMessageGroup(messageGroup);