private void scheduleGroupToForceComplete(Object groupId) { MessageGroup messageGroup = this.messageStore.getMessageGroup(groupId); scheduleGroupToForceComplete(messageGroup); }
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); } }
private boolean removeDelayedMessageFromMessageStore(Message<?> message) { if (this.messageStore instanceof SimpleMessageStore) { synchronized (this.messageGroupId) { Collection<Message<?>> messages = this.messageStore.getMessageGroup(this.messageGroupId).getMessages(); if (messages.contains(message)) { this.messageStore.removeMessagesFromGroup(this.messageGroupId, message); return true; } else { return false; } } } else { return ((MessageStore) this.messageStore).removeMessage(message.getHeaders().getId()) != null; } }
@Test public void testExpiry() throws Exception { messageStore.addMessageToGroup("FOO", new GenericMessage<String>("foo")); assertEquals(1, messageStore.getMessageGroup("FOO").size()); // wait for expiry... int n = 0; while (n++ < 200 & messageStore.getMessageGroup("FOO").size() > 0) { Thread.sleep(50); } assertEquals(0, messageStore.getMessageGroup("FOO").size()); assertEquals(1, expiryCallback.groups.size()); }
@Test @DirtiesContext public void testAggregation() { input.send(createMessage("123", "id1", 3, 1, null)); assertEquals(1, messageGroupStore.getMessageGroup("id1").size()); input.send(createMessage("789", "id1", 3, 3, null)); assertEquals(2, messageGroupStore.getMessageGroup("id1").size()); input.send(createMessage("456", "id1", 3, 2, null)); assertEquals("One and only one message should have been aggregated", 1, aggregatorBean .getAggregatedMessages().size()); Message<?> aggregatedMessage = aggregatorBean.getAggregatedMessages().get("id1"); assertEquals("The aggregated message payload is not correct", "123456789", aggregatedMessage .getPayload()); }
@Test @DirtiesContext public void testExpiry() { input.send(createMessage("123", "id1", 3, 1, null)); assertEquals(1, messageGroupStore.getMessageGroup("id1").size()); input.send(createMessage("456", "id1", 3, 2, null)); assertEquals(2, messageGroupStore.getMessageGroup("id1").size()); this.controlBusChannel.send(new GenericMessage<Object>("@messageStore.expireMessageGroups(-10000)")); assertEquals("One and only one message should have been aggregated", 1, aggregatorBean .getAggregatedMessages().size()); Message<?> aggregatedMessage = aggregatorBean.getAggregatedMessages().get("id1"); assertEquals("The aggregated message payload is not correct", "123456", aggregatedMessage .getPayload()); }
@Test @DirtiesContext public void testActivatorSendsToPersistentQueue() throws Exception { input.send(createMessage("123", "id1", 3, 1, null)); handler.getLatch().await(100, TimeUnit.MILLISECONDS); assertEquals("The message payload is not correct", "123", handler.getMessageString()); // The group id for buffered messages is the channel name assertEquals(1, messageGroupStore.getMessageGroup("messageStore:output").size()); Message<?> result = output.receive(100); assertEquals("hello", result.getPayload()); assertEquals(0, messageGroupStore.getMessageGroup(BASE_PACKAGE + ".store:output").size()); }
@Test @MongoDbAvailable public void testNonExistingEmptyMessageGroup() throws Exception { this.cleanupCollections(new SimpleMongoDbFactory(new MongoClient(), "test")); MessageGroupStore store = getMessageGroupStore(); store.addMessagesToGroup(1, new GenericMessage<Object>("foo")); MessageGroup messageGroup = store.getMessageGroup(1); assertNotNull(messageGroup); assertThat(messageGroup.getClass().getName(), containsString("PersistentMessageGroup")); assertEquals(1, messageGroup.size()); }
@Test @MongoDbAvailable public void testCompleteMessageGroup() throws Exception { this.cleanupCollections(new SimpleMongoDbFactory(new MongoClient(), "test")); MessageGroupStore store = this.getMessageGroupStore(); MessageGroup messageGroup = store.getMessageGroup(1); assertNotNull(messageGroup); Message<?> message = new GenericMessage<String>("Hello"); store.addMessagesToGroup(messageGroup.getGroupId(), message); store.completeGroup(messageGroup.getGroupId()); messageGroup = store.getMessageGroup(1); assertTrue(messageGroup.isComplete()); }
@Test @MongoDbAvailable public void testLastReleasedSequenceNumber() throws Exception { this.cleanupCollections(new SimpleMongoDbFactory(new MongoClient(), "test")); MessageGroupStore store = this.getMessageGroupStore(); MessageGroup messageGroup = store.getMessageGroup(1); assertNotNull(messageGroup); Message<?> message = new GenericMessage<String>("Hello"); store.addMessagesToGroup(messageGroup.getGroupId(), message); store.setLastReleasedSequenceNumberForGroup(messageGroup.getGroupId(), 5); messageGroup = store.getMessageGroup(1); assertEquals(5, messageGroup.getLastReleasedMessageSequenceNumber()); }
@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)); }
@Test public void testRemovalOfBarrierWhenLastMessageOfSequenceArrives() { QueueChannel replyChannel = new QueueChannel(); String correlationId = "ABC"; Message<?> message1 = createMessage("123", correlationId, 1, 1, replyChannel); resequencer.handleMessage(message1); assertEquals(0, store.getMessageGroup(correlationId).size()); }
@Test @MongoDbAvailable public void testAddAndRemoveMessagesFromMessageGroup() throws Exception { MessageGroupStore messageStore = (MessageGroupStore) this.getMessageStore(); String groupId = "X"; messageStore.removeMessageGroup("X"); ((AbstractBatchingMessageGroupStore) messageStore).setRemoveBatchSize(10); List<Message<?>> messages = new ArrayList<Message<?>>(); for (int i = 0; i < 25; i++) { Message<String> message = MessageBuilder.withPayload("foo").setCorrelationId(groupId).build(); messageStore.addMessagesToGroup(groupId, message); messages.add(message); } MessageGroup group = messageStore.getMessageGroup(groupId); assertEquals(25, group.size()); messageStore.removeMessagesFromGroup(groupId, messages); group = messageStore.getMessageGroup(groupId); assertEquals(0, group.size()); }
@Test @MongoDbAvailable public void testRemoveMessageFromTheGroup() throws Exception { this.cleanupCollections(new SimpleMongoDbFactory(new MongoClient(), "test")); MessageGroupStore store = this.getMessageGroupStore(); MessageGroup messageGroup = store.getMessageGroup(1); Message<?> message = new GenericMessage<String>("2"); store.addMessagesToGroup(1, new GenericMessage<String>("1"), message); messageGroup = store.addMessageToGroup(1, new GenericMessage<String>("3")); assertNotNull(messageGroup); assertEquals(3, messageGroup.size()); store.removeMessagesFromGroup(1, message); messageGroup = store.getMessageGroup(1); assertEquals(2, messageGroup.size()); }
@Test @MongoDbAvailable public void testRemoveMessageGroup() throws Exception { this.cleanupCollections(new SimpleMongoDbFactory(new MongoClient(), "test")); MessageGroupStore store = this.getMessageGroupStore(); MessageStore messageStore = this.getMessageStore(); MessageGroup messageGroup = store.getMessageGroup(1); Message<?> message = new GenericMessage<String>("Hello"); UUID id = message.getHeaders().getId(); messageGroup = store.addMessageToGroup(1, message); assertNotNull(messageGroup); assertEquals(1, messageGroup.size()); message = messageStore.getMessage(id); assertNotNull(message); store.removeMessageGroup(1); MessageGroup messageGroupA = store.getMessageGroup(1); assertEquals(0, messageGroupA.size()); assertFalse(messageGroupA.equals(messageGroup)); }
@Test @MongoDbAvailable public void testMultipleMessageStores() throws Exception { this.cleanupCollections(new SimpleMongoDbFactory(new MongoClient(), "test")); MessageGroupStore store1 = this.getMessageGroupStore(); MessageGroupStore store2 = this.getMessageGroupStore(); Message<?> message = new GenericMessage<String>("1"); store1.addMessagesToGroup(1, message, new GenericMessage<String>("2"), new GenericMessage<String>("3")); MessageGroupStore store3 = this.getMessageGroupStore(); MessageGroup messageGroup = store3.getMessageGroup(1); assertNotNull(messageGroup); assertEquals(3, messageGroup.size()); store3.removeMessagesFromGroup(1, message); messageGroup = store2.getMessageGroup(1); assertEquals(2, messageGroup.size()); }
@Test public void batchingWithLeftovers() { QueueChannel outputChannel = new QueueChannel(); QueueChannel discardChannel = new QueueChannel(); defaultHandler.setOutputChannel(outputChannel); defaultHandler.setDiscardChannel(discardChannel); defaultHandler.setReleaseStrategy(new SampleSizeReleaseStrategy()); defaultHandler.setExpireGroupsUponCompletion(true); for (int i = 0; i < 12; i++) { defaultHandler.handleMessage(MessageBuilder.withPayload(i).setCorrelationId("A").build()); } assertEquals(5, ((List<?>) outputChannel.receive(0).getPayload()).size()); assertEquals(5, ((List<?>) outputChannel.receive(0).getPayload()).size()); assertNull(discardChannel.receive(0)); assertEquals(2, store.getMessageGroup("A").getMessages().size()); }
@Test @MongoDbAvailable public void testMessageGroupWithAddedMessagePrimitiveGroupId() throws Exception { this.cleanupCollections(new SimpleMongoDbFactory(new MongoClient(), "test")); MessageGroupStore store = this.getMessageGroupStore(); MessageStore messageStore = this.getMessageStore(); MessageGroup messageGroup = store.getMessageGroup(1); Message<?> messageA = new GenericMessage<String>("A"); Message<?> messageB = new GenericMessage<String>("B"); store.addMessagesToGroup(1, messageA); messageGroup = store.addMessageToGroup(1, messageB); assertNotNull(messageGroup); assertEquals(2, messageGroup.size()); Message<?> retrievedMessage = messageStore.getMessage(messageA.getHeaders().getId()); assertNotNull(retrievedMessage); assertEquals(retrievedMessage.getHeaders().getId(), messageA.getHeaders().getId()); // ensure that 'message_group' header that is only used internally is not propagated assertNull(retrievedMessage.getHeaders().get("message_group")); }
@Test public void validateUnboundedResequencerDeep() { MessageChannel inputChannel = context.getBean("resequencerDeepInput", MessageChannel.class); QueueChannel outputChannel = context.getBean("outputChannel", QueueChannel.class); EventDrivenConsumer edc = context.getBean("resequencerDeep", EventDrivenConsumer.class); ResequencingMessageHandler handler = TestUtils.getPropertyValue(edc, "handler", ResequencingMessageHandler.class); MessageGroupStore store = TestUtils.getPropertyValue(handler, "messageStore", MessageGroupStore.class); Message<?> message1 = MessageBuilder.withPayload("1").setCorrelationId("A").setSequenceNumber(1).build(); Message<?> message2 = MessageBuilder.withPayload("2").setCorrelationId("A").setSequenceNumber(2).build(); Message<?> message3 = MessageBuilder.withPayload("3").setCorrelationId("A").setSequenceNumber(3).build(); inputChannel.send(message3); assertNull(outputChannel.receive(0)); inputChannel.send(message1); assertNotNull(outputChannel.receive(0)); inputChannel.send(message2); assertNotNull(outputChannel.receive(0)); assertNotNull(outputChannel.receive(0)); assertEquals(0, store.getMessageGroup("A").getMessages().size()); }
@Test public void testResequence() { input.send(createMessage("123", "id1", 3, 1, null)); assertEquals(1, messageGroupStore.getMessageGroup("id1").size()); input.send(createMessage("789", "id1", 3, 3, null)); assertEquals(2, messageGroupStore.getMessageGroup("id1").size()); input.send(createMessage("456", "id1", 3, 2, null)); Message<?> message1 = output.receive(500); Message<?> message2 = output.receive(500); Message<?> message3 = output.receive(500); assertNotNull(message1); assertEquals(1, new IntegrationMessageHeaderAccessor(message1).getSequenceNumber()); assertNotNull(message2); assertEquals(2, new IntegrationMessageHeaderAccessor(message2).getSequenceNumber()); assertNotNull(message3); assertEquals(3, new IntegrationMessageHeaderAccessor(message3).getSequenceNumber()); }