Example usage for org.springframework.integration.history MessageHistory HEADER_NAME

List of usage examples for org.springframework.integration.history MessageHistory HEADER_NAME

Introduction

In this page you can find the example usage for org.springframework.integration.history MessageHistory HEADER_NAME.

Prototype

String HEADER_NAME

To view the source code for org.springframework.integration.history MessageHistory HEADER_NAME.

Click Source Link

Usage

From source file:com.apress.prospringintegration.messagehistory.MessageHistoryApp.java

public static void main(String[] args) {
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(
            "classpath:messagehistory/message-history-context.xml");

    MessageChannel input = context.getBean("input", MessageChannel.class);

    PollableChannel output = context.getBean("output", PollableChannel.class);
    input.send(MessageBuilder.withPayload("Pro Spring Integration Example").build());
    Message<?> reply = output.receive();

    Iterator<Properties> historyIterator = reply.getHeaders()
            .get(MessageHistory.HEADER_NAME, MessageHistory.class).iterator();

    while (historyIterator.hasNext()) {
        Properties properties = historyIterator.next();
        System.out.println(properties);
    }//from  ww  w  . j  av a  2 s .  c  o  m

    System.out.println("received: " + reply);
}

From source file:com.googlecode.msidor.springframework.integration.history.MessageHistoryParser.java

/**
 * Parse message history generated by spring integration and produce output with components names and components processing times
 * /*from   ww  w .  j  a  v  a 2s.c  o  m*/
 * @param mh message headers to be parsed
 * @return output with components names and components processing times
 */
public static String parse(MessageHeaders mh) {
    StringBuilder sb = new StringBuilder();

    //get message history
    MessageHistory history = mh.get(MessageHistory.HEADER_NAME, MessageHistory.class);
    String[] names = new String[history.size()];
    long[] times = new long[history.size()];

    //go thought all history entries
    Iterator<Properties> historyIterator = history.iterator();
    int i = 0;
    while (historyIterator.hasNext()) {
        Properties gatewayHistory = historyIterator.next();
        String name = gatewayHistory.getProperty("name");
        String historyTimestampStr = gatewayHistory.getProperty("timestamp");
        Long historyTimestamp = Long.parseLong(historyTimestampStr);

        names[i] = name;
        times[i++] = historyTimestamp;
    }

    //calculates the time deltas between components 
    final long lastTimestamp = mh.getTimestamp();
    for (int j = 0; j < names.length; j++) {
        if (j > 0) {
            sb.append("; ");
        }

        if (j + 1 < names.length)
            sb.append(names[j]).append("=").append(times[j + 1] - times[j]);
        else
            sb.append(names[j]).append("=").append(lastTimestamp - times[j]);
    }

    if (sb.length() > 0) {
        sb.append("; ");
    }

    sb.append("total=").append(lastTimestamp - times[0]);

    return sb.toString();
}

From source file:org.springframework.integration.configuration.EnableIntegrationTests.java

@Test
public void testAnnotatedServiceActivator() throws Exception {
    this.serviceActivatorEndpoint.setReceiveTimeout(10000);
    this.serviceActivatorEndpoint.start();
    assertTrue(this.inputReceiveLatch.await(10, TimeUnit.SECONDS));

    assertEquals(10L, TestUtils.getPropertyValue(this.serviceActivatorEndpoint, "maxMessagesPerPoll"));

    Trigger trigger = TestUtils.getPropertyValue(this.serviceActivatorEndpoint, "trigger", Trigger.class);
    assertThat(trigger, Matchers.instanceOf(PeriodicTrigger.class));
    assertEquals(100L, TestUtils.getPropertyValue(trigger, "period"));
    assertFalse(TestUtils.getPropertyValue(trigger, "fixedRate", Boolean.class));

    assertTrue(this.annotationTestService.isRunning());
    Log logger = spy(TestUtils.getPropertyValue(this.serviceActivatorEndpoint, "logger", Log.class));
    when(logger.isDebugEnabled()).thenReturn(true);
    final CountDownLatch pollerInterruptedLatch = new CountDownLatch(1);
    doAnswer(invocation -> {//  ww w  .j  a  v  a  2  s . com
        pollerInterruptedLatch.countDown();
        invocation.callRealMethod();
        return null;
    }).when(logger).debug("Received no Message during the poll, returning 'false'");
    new DirectFieldAccessor(this.serviceActivatorEndpoint).setPropertyValue("logger", logger);

    this.serviceActivatorEndpoint.stop();
    assertFalse(this.annotationTestService.isRunning());

    // wait until the service activator's poller is interrupted.
    assertTrue(pollerInterruptedLatch.await(10, TimeUnit.SECONDS));
    this.serviceActivatorEndpoint.start();
    assertTrue(this.annotationTestService.isRunning());

    trigger = TestUtils.getPropertyValue(this.serviceActivatorEndpoint1, "trigger", Trigger.class);
    assertThat(trigger, Matchers.instanceOf(PeriodicTrigger.class));
    assertEquals(100L, TestUtils.getPropertyValue(trigger, "period"));
    assertTrue(TestUtils.getPropertyValue(trigger, "fixedRate", Boolean.class));

    trigger = TestUtils.getPropertyValue(this.serviceActivatorEndpoint2, "trigger", Trigger.class);
    assertThat(trigger, Matchers.instanceOf(CronTrigger.class));
    assertEquals("0 5 7 * * *", TestUtils.getPropertyValue(trigger, "sequenceGenerator.expression"));

    trigger = TestUtils.getPropertyValue(this.serviceActivatorEndpoint3, "trigger", Trigger.class);
    assertThat(trigger, Matchers.instanceOf(PeriodicTrigger.class));
    assertEquals(11L, TestUtils.getPropertyValue(trigger, "period"));
    assertFalse(TestUtils.getPropertyValue(trigger, "fixedRate", Boolean.class));

    trigger = TestUtils.getPropertyValue(this.serviceActivatorEndpoint4, "trigger", Trigger.class);
    assertThat(trigger, Matchers.instanceOf(PeriodicTrigger.class));
    assertEquals(1000L, TestUtils.getPropertyValue(trigger, "period"));
    assertFalse(TestUtils.getPropertyValue(trigger, "fixedRate", Boolean.class));
    assertSame(this.myTrigger, trigger);

    trigger = TestUtils.getPropertyValue(this.transformer, "trigger", Trigger.class);
    assertThat(trigger, Matchers.instanceOf(PeriodicTrigger.class));
    assertEquals(10L, TestUtils.getPropertyValue(trigger, "period"));
    assertFalse(TestUtils.getPropertyValue(trigger, "fixedRate", Boolean.class));

    this.input.send(MessageBuilder.withPayload("Foo").build());

    Message<?> interceptedMessage = this.wireTapChannel.receive(10000);
    assertNotNull(interceptedMessage);
    assertEquals("Foo", interceptedMessage.getPayload());

    Message<?> receive = this.output.receive(10000);
    assertNotNull(receive);
    assertEquals("FOO", receive.getPayload());

    receive = this.wireTapFromOutput.receive(10000);
    assertNotNull(receive);
    assertEquals("FOO", receive.getPayload());

    MessageHistory messageHistory = receive.getHeaders().get(MessageHistory.HEADER_NAME, MessageHistory.class);
    assertNotNull(messageHistory);
    String messageHistoryString = messageHistory.toString();
    assertThat(messageHistoryString, Matchers.containsString("input"));
    assertThat(messageHistoryString,
            Matchers.containsString("annotationTestService.handle.serviceActivator.handler"));
    assertThat(messageHistoryString, Matchers.not(Matchers.containsString("output")));

    receive = this.publishedChannel.receive(10000);

    assertNotNull(receive);
    assertEquals("foo", receive.getPayload());

    messageHistory = receive.getHeaders().get(MessageHistory.HEADER_NAME, MessageHistory.class);
    assertNotNull(messageHistory);
    messageHistoryString = messageHistory.toString();
    assertThat(messageHistoryString, Matchers.not(Matchers.containsString("input")));
    assertThat(messageHistoryString, Matchers.not(Matchers.containsString("output")));
    assertThat(messageHistoryString, Matchers.containsString("publishedChannel"));

    assertNull(this.wireTapChannel.receive(0));
    assertThat(this.testChannelInterceptor.getInvoked(), Matchers.greaterThan(0));
    assertThat(this.fbInterceptorCounter.get(), Matchers.greaterThan(0));

    assertTrue(this.context.containsBean("annotationTestService.count.inboundChannelAdapter.source"));
    Object messageSource = this.context.getBean("annotationTestService.count.inboundChannelAdapter.source");
    assertThat(messageSource, Matchers.instanceOf(MethodInvokingMessageSource.class));

    assertNull(this.counterChannel.receive(10));

    SmartLifecycle countSA = this.context.getBean("annotationTestService.count.inboundChannelAdapter",
            SmartLifecycle.class);
    assertFalse(countSA.isAutoStartup());
    assertEquals(23, countSA.getPhase());
    countSA.start();

    for (int i = 0; i < 10; i++) {
        Message<?> message = this.counterChannel.receive(1000);
        assertNotNull(message);
        assertEquals(i + 1, message.getPayload());
    }

    Message<?> message = this.fooChannel.receive(1000);
    assertNotNull(message);
    assertEquals("foo", message.getPayload());
    message = this.fooChannel.receive(1000);
    assertNotNull(message);
    assertEquals("foo", message.getPayload());
    assertNull(this.fooChannel.receive(10));

    message = this.messageChannel.receive(1000);
    assertNotNull(message);
    assertEquals("bar", message.getPayload());
    assertTrue(message.getHeaders().containsKey("foo"));
    assertEquals("FOO", message.getHeaders().get("foo"));

    MessagingTemplate messagingTemplate = new MessagingTemplate(this.controlBusChannel);
    assertFalse(messagingTemplate.convertSendAndReceive("@lifecycle.isRunning()", Boolean.class));
    this.controlBusChannel.send(new GenericMessage<String>("@lifecycle.start()"));
    assertTrue(messagingTemplate.convertSendAndReceive("@lifecycle.isRunning()", Boolean.class));
    this.controlBusChannel.send(new GenericMessage<String>("@lifecycle.stop()"));
    assertFalse(messagingTemplate.convertSendAndReceive("@lifecycle.isRunning()", Boolean.class));
}

From source file:org.springframework.integration.history.MessageHistoryIntegrationTests.java

@Test
public void testMessageHistoryWithHistoryWriter() {
    ConfigurableApplicationContext ac = new ClassPathXmlApplicationContext(
            "messageHistoryWithHistoryWriter.xml", MessageHistoryIntegrationTests.class);
    SampleGateway gateway = ac.getBean("sampleGateway", SampleGateway.class);
    DirectChannel endOfThePipeChannel = ac.getBean("endOfThePipeChannel", DirectChannel.class);
    MessageHandler handler = Mockito.spy(new MessageHandler() {
        @Override//from   ww  w.ja  va  2s  .c o  m
        public void handleMessage(Message<?> message) {
            Iterator<Properties> historyIterator = message.getHeaders()
                    .get(MessageHistory.HEADER_NAME, MessageHistory.class).iterator();

            Properties event = historyIterator.next();
            assertEquals("sampleGateway", event.getProperty(MessageHistory.NAME_PROPERTY));
            assertEquals("gateway", event.getProperty(MessageHistory.TYPE_PROPERTY));

            event = historyIterator.next();
            assertEquals("bridgeInChannel", event.getProperty(MessageHistory.NAME_PROPERTY));
            assertEquals("channel", event.getProperty(MessageHistory.TYPE_PROPERTY));

            event = historyIterator.next();
            assertEquals("testBridge", event.getProperty(MessageHistory.NAME_PROPERTY));
            assertEquals("bridge", event.getProperty(MessageHistory.TYPE_PROPERTY));

            event = historyIterator.next();
            assertEquals("headerEnricherChannel", event.getProperty(MessageHistory.NAME_PROPERTY));
            assertEquals("channel", event.getProperty(MessageHistory.TYPE_PROPERTY));

            event = historyIterator.next();
            assertEquals("testHeaderEnricher", event.getProperty(MessageHistory.NAME_PROPERTY));
            assertEquals("transformer", event.getProperty(MessageHistory.TYPE_PROPERTY));

            event = historyIterator.next();
            assertEquals("chainChannel", event.getProperty(MessageHistory.NAME_PROPERTY));
            assertEquals("channel", event.getProperty(MessageHistory.TYPE_PROPERTY));

            event = historyIterator.next();
            assertEquals("sampleChain", event.getProperty(MessageHistory.NAME_PROPERTY));
            assertEquals("chain", event.getProperty(MessageHistory.TYPE_PROPERTY));

            event = historyIterator.next();
            assertEquals("sampleChain$child.service-activator-within-chain",
                    event.getProperty(MessageHistory.NAME_PROPERTY));
            assertEquals("service-activator", event.getProperty(MessageHistory.TYPE_PROPERTY));

            event = historyIterator.next();
            assertEquals("filterChannel", event.getProperty(MessageHistory.NAME_PROPERTY));
            assertEquals("channel", event.getProperty(MessageHistory.TYPE_PROPERTY));

            event = historyIterator.next();
            assertEquals("testFilter", event.getProperty(MessageHistory.NAME_PROPERTY));
            assertEquals("filter", event.getProperty(MessageHistory.TYPE_PROPERTY));

            event = historyIterator.next();
            assertEquals("splitterChannel", event.getProperty(MessageHistory.NAME_PROPERTY));
            assertEquals("channel", event.getProperty(MessageHistory.TYPE_PROPERTY));

            event = historyIterator.next();
            assertEquals("testSplitter", event.getProperty(MessageHistory.NAME_PROPERTY));
            assertEquals("splitter", event.getProperty(MessageHistory.TYPE_PROPERTY));

            event = historyIterator.next();
            assertEquals("aggregatorChannel", event.getProperty(MessageHistory.NAME_PROPERTY));
            assertEquals("channel", event.getProperty(MessageHistory.TYPE_PROPERTY));

            event = historyIterator.next();
            assertEquals("testAggregator", event.getProperty(MessageHistory.NAME_PROPERTY));
            assertEquals("aggregator", event.getProperty(MessageHistory.TYPE_PROPERTY));

            event = historyIterator.next();
            assertEquals("endOfThePipeChannel", event.getProperty(MessageHistory.NAME_PROPERTY));
            assertEquals("channel", event.getProperty(MessageHistory.TYPE_PROPERTY));

            MessageChannel replyChannel = (MessageChannel) message.getHeaders().getReplyChannel();
            replyChannel.send(message);
        }
    });
    endOfThePipeChannel.subscribe(handler);
    Message<?> result = gateway.echo("hello");
    Mockito.verify(handler, Mockito.times(1)).handleMessage(Mockito.any(Message.class));
    assertNotNull(result);
    //assertEquals("hello", result);
    ac.close();
}

From source file:org.springframework.integration.history.MessageHistoryIntegrationTests.java

@Test
public void testMessageHistoryWithoutHistoryWriter() {
    ConfigurableApplicationContext ac = new ClassPathXmlApplicationContext(
            "messageHistoryWithoutHistoryWriter.xml", MessageHistoryIntegrationTests.class);
    SampleGateway gateway = ac.getBean("sampleGateway", SampleGateway.class);
    DirectChannel endOfThePipeChannel = ac.getBean("endOfThePipeChannel", DirectChannel.class);
    MessageHandler handler = Mockito.spy(new MessageHandler() {
        @Override//w w  w .j a  v  a  2 s  .  co  m
        public void handleMessage(Message<?> message) {
            assertNull(message.getHeaders().get(MessageHistory.HEADER_NAME, MessageHistory.class));
            MessageChannel replyChannel = (MessageChannel) message.getHeaders().getReplyChannel();
            replyChannel.send(message);
        }
    });
    endOfThePipeChannel.subscribe(handler);
    gateway.echo("hello");
    Mockito.verify(handler, Mockito.times(1)).handleMessage(Mockito.any(Message.class));
    ac.close();
}

From source file:org.springframework.integration.history.MessageHistoryIntegrationTests.java

@Test
public void testMessageHistoryParser() {
    ConfigurableApplicationContext ac = new ClassPathXmlApplicationContext(
            "messageHistoryWithHistoryWriterNamespace.xml", MessageHistoryIntegrationTests.class);
    SampleGateway gateway = ac.getBean("sampleGateway", SampleGateway.class);
    DirectChannel endOfThePipeChannel = ac.getBean("endOfThePipeChannel", DirectChannel.class);
    MessageHandler handler = Mockito.spy(new MessageHandler() {
        @Override/*from www  .  j  ava 2s . c o m*/
        public void handleMessage(Message<?> message) {
            Iterator<Properties> historyIterator = message.getHeaders()
                    .get(MessageHistory.HEADER_NAME, MessageHistory.class).iterator();
            assertTrue(historyIterator.hasNext());
            MessageChannel replyChannel = (MessageChannel) message.getHeaders().getReplyChannel();
            replyChannel.send(message);
        }
    });
    endOfThePipeChannel.subscribe(handler);
    gateway.echo("hello");
    Mockito.verify(handler, Mockito.times(1)).handleMessage(Mockito.any(Message.class));
    ac.close();
}

From source file:org.springframework.integration.history.MessageHistoryIntegrationTests.java

@Test
public void testMessageHistoryParserWithNamePatterns() {
    ConfigurableApplicationContext ac = new ClassPathXmlApplicationContext(
            "messageHistoryWithHistoryWriterNamespaceAndPatterns.xml", MessageHistoryIntegrationTests.class);
    SampleGateway gateway = ac.getBean("sampleGateway", SampleGateway.class);
    DirectChannel endOfThePipeChannel = ac.getBean("endOfThePipeChannel", DirectChannel.class);
    MessageHandler handler = Mockito.spy(new MessageHandler() {
        @Override//from   www. j  a v  a 2 s .  co  m
        public void handleMessage(Message<?> message) {
            Iterator<Properties> historyIterator = message.getHeaders()
                    .get(MessageHistory.HEADER_NAME, MessageHistory.class).iterator();
            assertTrue(historyIterator.hasNext());
            Properties gatewayHistory = historyIterator.next();
            assertEquals("sampleGateway", gatewayHistory.get("name"));
            assertTrue(historyIterator.hasNext());
            Properties chainHistory = historyIterator.next();
            assertEquals("sampleChain", chainHistory.get("name"));
            assertFalse(historyIterator.hasNext());
            MessageChannel replyChannel = (MessageChannel) message.getHeaders().getReplyChannel();
            replyChannel.send(message);
        }
    });
    endOfThePipeChannel.subscribe(handler);
    gateway.echo("hello");
    Mockito.verify(handler, Mockito.times(1)).handleMessage(Mockito.any(Message.class));
    ac.close();
}