@Test(invocationCount = 5, successPercentage = 19)
  public void topicConduit() throws Exception {
    String topicName =
        "JmsByteArrayTransportTest-topicConduit-"
            + System.getProperty("user.name")
            + "-"
            + System.currentTimeMillis();
    ConnectionFactory cf = ActiveMQTestUtils.createTestConnectionFactory();
    JmsTemplate jmsTemplate = new JmsTemplate();
    jmsTemplate.setConnectionFactory(cf);
    jmsTemplate.setPubSubDomain(true);

    JmsByteArrayMessageSender messageSender = new JmsByteArrayMessageSender(topicName, jmsTemplate);
    CollectingByteArrayMessageReceiver collectingReceiver =
        new CollectingByteArrayMessageReceiver();
    JmsByteArrayMessageDispatcher messageDispatcher =
        new JmsByteArrayMessageDispatcher(collectingReceiver);

    DefaultMessageListenerContainer container = new DefaultMessageListenerContainer();
    container.setConnectionFactory(cf);
    container.setMessageListener(messageDispatcher);
    container.setDestinationName(topicName);
    container.setPubSubDomain(true);
    container.afterPropertiesSet();
    container.start();

    Random random = new Random();
    byte[] randomBytes = new byte[1024];
    random.nextBytes(randomBytes);

    while (!container.isRunning()) {
      Thread.sleep(10l);
    }
    // TODO: this is a hack.  The context doesn't seem to have always set up the consumer completely
    // yet
    Thread.sleep(500l);

    messageSender.send(randomBytes);
    long startTime = System.currentTimeMillis();
    while (collectingReceiver.getMessages().isEmpty()) {
      Thread.sleep(10l);
      if ((System.currentTimeMillis() - startTime) > TIMEOUT) {
        fail("Did not receive a message in " + (TIMEOUT / 1000) + " seconds.");
      }
    }
    s_logger.debug(
        "topicConduit message received {}ms before timeout limit",
        TIMEOUT - (System.currentTimeMillis() - startTime));
    assertEquals(1, collectingReceiver.getMessages().size());
    byte[] receivedBytes = collectingReceiver.getMessages().get(0);
    assertEquals(randomBytes.length, receivedBytes.length);
    for (int i = 0; i < randomBytes.length; i++) {
      assertEquals(randomBytes[i], receivedBytes[i]);
    }

    container.stop();
    container.destroy();
  }
  @Override
  @Transactional("jmsTxManager")
  @CacheEvict(
      value = {"fixedDepositList"},
      allEntries = true,
      beforeInvocation = true)
  public void createFixedDeposit(final FixedDepositDetails fdd) throws Exception {
    logger.info("createFixedDeposit method invoked");
    jmsTemplate.send(
        "emailQueueDestination",
        new MessageCreator() {
          @Override
          public Message createMessage(Session session) throws JMSException {
            TextMessage textMessage = session.createTextMessage();
            textMessage.setText(fdd.getEmail());
            return textMessage;
          }
        });

    // --this JMS message goes to the default destination configured for the
    // JmsTemplate
    jmsTemplate.send(
        new MessageCreator() {
          @Override
          public Message createMessage(Session session) throws JMSException {
            ObjectMessage objectMessage = session.createObjectMessage();
            objectMessage.setObject(fdd);
            return objectMessage;
          }
        });
  }
  public static void main(String[] args) {
    ClassPathXmlApplicationContext context =
        new ClassPathXmlApplicationContext("classpath:integration-transformer.xml");

    JmsTemplate jmsTemplate = context.getBean("jmsTemplate", JmsTemplate.class);

    jmsTemplate.send(
        new MessageCreator() {

          @Override
          public javax.jms.Message createMessage(Session session) throws JMSException {
            MapMessage message = session.createMapMessage();
            message.setString("firstName", "John");
            message.setString("lastName", "Smith");
            message.setString("address", "100 State Street");
            message.setString("city", "Los Angeles");
            message.setString("state", "CA");
            message.setString("zip", "90064");
            System.out.println("Sending message: " + message);
            return message;
          }
        });

    PollableChannel output = (PollableChannel) context.getBean("output");
    Message<?> reply = output.receive();
    System.out.println("received: " + reply.getPayload());
  }
  @Test
  public void testReceiveMessageWithJmsTemplate() {
    JmsMessageReceiver receiver = new JmsMessageReceiver();
    receiver.setJmsTemplate(jmsTemplate);

    Map<String, Object> controlHeaders = new HashMap<String, Object>();
    final Message<String> controlMessage =
        MessageBuilder.withPayload("<TestRequest><Message>Hello World!</Message></TestRequest>")
            .copyHeaders(controlHeaders)
            .build();

    reset(jmsTemplate, connectionFactory, destination);

    jmsTemplate.setReceiveTimeout(5000L);
    expectLastCall().once();

    expect(jmsTemplate.getDefaultDestination()).andReturn(destination).atLeastOnce();

    expect(jmsTemplate.receiveAndConvert()).andReturn(controlMessage);

    replay(jmsTemplate, connectionFactory, destination);

    Message<?> receivedMessage = receiver.receive();
    Assert.assertTrue(receivedMessage.equals(controlMessage));

    verify(jmsTemplate, connectionFactory, destination);
  }
Esempio n. 5
0
  @Test
  public void validateSuccessfulConsumeAndTransferToSuccess() throws Exception {
    JmsTemplate jmsTemplate = CommonTest.buildJmsTemplateForDestination("cooQueue", false);
    JMSPublisher sender = new JMSPublisher(jmsTemplate, mock(ComponentLog.class));
    sender.publish("Hey dude!".getBytes());
    TestRunner runner = TestRunners.newTestRunner(new ConsumeJMS());
    JMSConnectionFactoryProviderDefinition cs = mock(JMSConnectionFactoryProviderDefinition.class);
    when(cs.getIdentifier()).thenReturn("cfProvider");
    when(cs.getConnectionFactory()).thenReturn(jmsTemplate.getConnectionFactory());
    runner.addControllerService("cfProvider", cs);
    runner.enableControllerService(cs);

    runner.setProperty(PublishJMS.CF_SERVICE, "cfProvider");
    runner.setProperty(ConsumeJMS.DESTINATION, "cooQueue");
    runner.setProperty(ConsumeJMS.DESTINATION_TYPE, ConsumeJMS.QUEUE);
    runner.run(1, false);
    //
    final MockFlowFile successFF =
        runner.getFlowFilesForRelationship(PublishJMS.REL_SUCCESS).get(0);
    assertNotNull(successFF);
    assertEquals("cooQueue", successFF.getAttributes().get(JmsHeaders.DESTINATION));
    successFF.assertContentEquals("Hey dude!".getBytes());

    ((CachingConnectionFactory) jmsTemplate.getConnectionFactory()).destroy();
  }
  @Test
  public void testWithReply() throws Exception {
    QueueChannel replies = new QueueChannel();
    this.gateway1.setOutputChannel(replies);
    this.gateway1.start();
    this.gateway1.handleMessage(
        MessageBuilder.withPayload("foo")
            .setHeader(
                JmsHeaders.CORRELATION_ID,
                "baz") // make sure it's restored in case we're from an upstream gw
            .build());
    JmsTemplate template = new JmsTemplate(this.ccf);
    template.setReceiveTimeout(10000);
    final Message received = template.receive("asyncTest1");
    assertNotNull(received);
    template.send(
        received.getJMSReplyTo(),
        new MessageCreator() {

          @Override
          public Message createMessage(Session session) throws JMSException {
            TextMessage textMessage = session.createTextMessage("bar");
            textMessage.setJMSCorrelationID(received.getJMSCorrelationID());
            return textMessage;
          }
        });
    org.springframework.messaging.Message<?> reply = replies.receive(10000);
    assertNotNull(reply);
    assertEquals("bar", reply.getPayload());
    assertEquals("baz", reply.getHeaders().get(JmsHeaders.CORRELATION_ID));
    this.gateway1.stop();
  }
Esempio n. 7
0
 // @PostConstruct
 public void init() {
   jmsTemplate.setConnectionFactory(jmsConnectionFactory);
   jmsTemplate.setDefaultDestination(truConnectQueue);
   jmsTemplate.setSessionTransacted(true);
   jmsTemplate.setDeliveryMode(DeliveryMode.PERSISTENT);
   jmsTemplate.setSessionAcknowledgeMode(Session.AUTO_ACKNOWLEDGE);
 }
 @Bean
 @Lazy
 public JmsTemplate jmsTemplate() {
   final JmsTemplate jmsTemplate = new JmsTemplate(amqConnectionFactory());
   jmsTemplate.setDefaultDestination(destination());
   jmsTemplate.setReceiveTimeout(1000);
   return jmsTemplate;
 }
 private void receiveAndSend(JmsTemplate template) {
   javax.jms.Message request = template.receive(requestQueue7);
   final javax.jms.Message jmsReply = request;
   try {
     template.send(request.getJMSReplyTo(), (MessageCreator) session -> jmsReply);
   } catch (JmsException | JMSException e) {
   }
 }
 @Bean
 public JmsTemplate jmsTemplate() {
   JmsTemplate jmsTemplate = new JmsTemplate();
   jmsTemplate.setConnectionFactory(connectionFactory());
   jmsTemplate.setDefaultDestinationName("mail.queue");
   jmsTemplate.setMessageConverter(mailMessageConverter());
   return jmsTemplate;
 }
 @Test
 public void pollingAdapterWithReceiveTimeout() {
   ClassPathXmlApplicationContext context =
       new ClassPathXmlApplicationContext("jmsInboundWithReceiveTimeout.xml", this.getClass());
   JmsTemplate jmsTemplate =
       TestUtils.getPropertyValue(
           context.getBean("adapter"), "source.jmsTemplate", JmsTemplate.class);
   assertEquals(99, jmsTemplate.getReceiveTimeout());
 }
 @Override
 public Object postProcessAfterInitialization(Object bean, String beanName)
     throws BeansException {
   if (bean.getClass().isAssignableFrom(JmsTemplate.class)) {
     JmsTemplate jmsTemplate = (JmsTemplate) bean;
     jmsTemplate.setPubSubDomain(true);
   }
   return bean;
 }
Esempio n. 13
0
 private void sendMessage(Object msg) {
   try {
     final String text = converter.toXML(msg);
     MessageCreator creator = session -> session.createTextMessage(text);
     JmsTemplate template = context.getBean(JmsTemplate.class);
     template.setConnectionFactory(connectionFactory);
     template.send(serverQueue, creator);
   } catch (Exception e) {
     log.warn("Exception " + e.toString() + " sending message - ignoring");
   }
 }
Esempio n. 14
0
 public void send(String target) {
   MessageCreator messageCreator =
       new MessageCreator() {
         @Override
         public Message createMessage(Session session) throws JMSException {
           return session.createTextMessage("test");
         }
       };
   JmsTemplate jmsTemplate = AppRun.getContext().getBean(JmsTemplate.class);
   jmsTemplate.send(target, messageCreator);
 }
 @Test
 public void testPubSubDomainOverride() {
   load(TestConfiguration.class, "spring.jms.pubSubDomain:false");
   JmsTemplate jmsTemplate = this.context.getBean(JmsTemplate.class);
   ActiveMQConnectionFactory connectionFactory =
       this.context.getBean(ActiveMQConnectionFactory.class);
   assertThat(jmsTemplate).isNotNull();
   assertThat(jmsTemplate.isPubSubDomain()).isFalse();
   assertThat(connectionFactory).isNotNull();
   assertThat(connectionFactory).isEqualTo(jmsTemplate.getConnectionFactory());
 }
 @Test
 public void testActiveMQOverriddenPoolAndStandalone() {
   load(TestConfiguration.class, "spring.activemq.pooled:true", "spring.activemq.inMemory:false");
   JmsTemplate jmsTemplate = this.context.getBean(JmsTemplate.class);
   PooledConnectionFactory pool = this.context.getBean(PooledConnectionFactory.class);
   assertThat(jmsTemplate).isNotNull();
   assertThat(pool).isNotNull();
   assertThat(pool).isEqualTo(jmsTemplate.getConnectionFactory());
   ActiveMQConnectionFactory factory = (ActiveMQConnectionFactory) pool.getConnectionFactory();
   assertThat(factory.getBrokerURL()).isEqualTo(ACTIVEMQ_NETWORK_URL);
 }
 @Test
 public void testPubSubDomainActive() {
   load(TestConfiguration.class, "spring.jms.pubSubDomain:true");
   JmsTemplate jmsTemplate = this.context.getBean(JmsTemplate.class);
   DefaultMessageListenerContainer defaultMessageListenerContainer =
       this.context
           .getBean(DefaultJmsListenerContainerFactory.class)
           .createListenerContainer(mock(JmsListenerEndpoint.class));
   assertThat(jmsTemplate.isPubSubDomain()).isTrue();
   assertThat(defaultMessageListenerContainer.isPubSubDomain()).isTrue();
 }
 @Test
 public void testActiveMQOverriddenRemoteHost() {
   load(TestConfiguration.class, "spring.activemq.brokerUrl:tcp://remote-host:10000");
   JmsTemplate jmsTemplate = this.context.getBean(JmsTemplate.class);
   ActiveMQConnectionFactory connectionFactory =
       this.context.getBean(ActiveMQConnectionFactory.class);
   assertThat(jmsTemplate).isNotNull();
   assertThat(connectionFactory).isNotNull();
   assertThat(connectionFactory).isEqualTo(jmsTemplate.getConnectionFactory());
   assertThat(((ActiveMQConnectionFactory) jmsTemplate.getConnectionFactory()).getBrokerURL())
       .isEqualTo("tcp://remote-host:10000");
 }
 @Test
 public void testActiveMQOverriddenStandalone() {
   load(TestConfiguration.class, "spring.activemq.inMemory:false");
   JmsTemplate jmsTemplate = this.context.getBean(JmsTemplate.class);
   ActiveMQConnectionFactory connectionFactory =
       this.context.getBean(ActiveMQConnectionFactory.class);
   assertThat(jmsTemplate).isNotNull();
   assertThat(connectionFactory).isNotNull();
   assertThat(connectionFactory).isEqualTo(jmsTemplate.getConnectionFactory());
   assertThat(((ActiveMQConnectionFactory) jmsTemplate.getConnectionFactory()).getBrokerURL())
       .isEqualTo(ACTIVEMQ_NETWORK_URL);
 }
 @Test
 public void topicReferenceChannel() {
   assertEquals(JmsDestinationBackedMessageChannel.class, topicReferenceChannel.getClass());
   JmsDestinationBackedMessageChannel channel =
       (JmsDestinationBackedMessageChannel) topicReferenceChannel;
   DirectFieldAccessor accessor = new DirectFieldAccessor(channel);
   JmsTemplate jmsTemplate = (JmsTemplate) accessor.getPropertyValue("jmsTemplate");
   AbstractMessageListenerContainer container =
       (AbstractMessageListenerContainer) accessor.getPropertyValue("container");
   assertEquals(topic, jmsTemplate.getDefaultDestination());
   assertEquals(topic, container.getDestination());
 }
 @Test
 public void testJmsTemplateBackOffEverything() {
   this.context =
       createContext(TestConfiguration2.class, TestConfiguration3.class, TestConfiguration5.class);
   JmsTemplate jmsTemplate = this.context.getBean(JmsTemplate.class);
   assertThat(jmsTemplate.getPriority()).isEqualTo(999);
   assertThat(this.context.getBean(ActiveMQConnectionFactory.class).getBrokerURL())
       .isEqualTo("foobar");
   JmsMessagingTemplate messagingTemplate = this.context.getBean(JmsMessagingTemplate.class);
   assertThat(messagingTemplate.getDefaultDestinationName()).isEqualTo("fooBar");
   assertThat(messagingTemplate.getJmsTemplate()).isEqualTo(jmsTemplate);
 }
 @Test
 public void adapterWithoutJmsTemplateAndAcknowlegeMode() {
   ClassPathXmlApplicationContext context =
       new ClassPathXmlApplicationContext("jmsInboundWithJmsTemplate.xml", this.getClass());
   JmsTemplate jmsTemplate =
       TestUtils.getPropertyValue(
           context.getBean("inboundAdapterWithoutJmsTemplate"),
           "source.jmsTemplate",
           JmsTemplate.class);
   assertEquals(0, jmsTemplate.getSessionAcknowledgeMode());
   context.stop();
 }
 @Test
 public void queueNameWithResolverChannel() {
   assertEquals(JmsDestinationBackedMessageChannel.class, queueNameWithResolverChannel.getClass());
   JmsDestinationBackedMessageChannel channel =
       (JmsDestinationBackedMessageChannel) queueNameWithResolverChannel;
   DirectFieldAccessor accessor = new DirectFieldAccessor(channel);
   JmsTemplate jmsTemplate = (JmsTemplate) accessor.getPropertyValue("jmsTemplate");
   AbstractMessageListenerContainer container =
       (AbstractMessageListenerContainer) accessor.getPropertyValue("container");
   assertEquals("foo", jmsTemplate.getDefaultDestinationName());
   assertEquals("foo", container.getDestinationName());
 }
Esempio n. 24
0
 public static void main(String[] args) {
   ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
   JmsTemplate jmsTemplate = (JmsTemplate) context.getBean("jmsTemplate");
   jmsTemplate.send(
       new MessageCreator() {
         public ObjectMessage createMessage(Session session) throws JMSException {
           ObjectMessage message = session.createObjectMessage();
           message.setObject("My first Message");
           return message;
         }
       });
   System.out.println("MESSAGE SENT TO myMessageQueue");
 }
 @Test
 public void gatewayWithReplyChannel() {
   ActiveMqTestUtils.prepare();
   ClassPathXmlApplicationContext context =
       new ClassPathXmlApplicationContext("jmsGatewayWithReplyChannel.xml", this.getClass());
   JmsMessageDrivenEndpoint gateway = (JmsMessageDrivenEndpoint) context.getBean("gateway");
   Object replyChannel =
       TestUtils.getPropertyValue(gateway, "listener.gatewayDelegate.replyChannel");
   assertEquals(context.getBean("replies"), replyChannel);
   JmsTemplate template = new JmsTemplate(context.getBean(ConnectionFactory.class));
   template.convertAndSend("testDestination", "Hello");
   assertNotNull(template.receive("testReplyDestination"));
 }
 @Test
 public void testDefaultJmsConfiguration() {
   load(TestConfiguration.class);
   ActiveMQConnectionFactory connectionFactory =
       this.context.getBean(ActiveMQConnectionFactory.class);
   JmsTemplate jmsTemplate = this.context.getBean(JmsTemplate.class);
   JmsMessagingTemplate messagingTemplate = this.context.getBean(JmsMessagingTemplate.class);
   assertThat(connectionFactory).isEqualTo(jmsTemplate.getConnectionFactory());
   assertThat(messagingTemplate.getJmsTemplate()).isEqualTo(jmsTemplate);
   assertThat(((ActiveMQConnectionFactory) jmsTemplate.getConnectionFactory()).getBrokerURL())
       .isEqualTo(ACTIVEMQ_EMBEDDED_URL);
   assertThat(this.context.containsBean("jmsListenerContainerFactory")).isTrue();
 }
Esempio n. 27
0
 public static void main(String[] args) {
   @SuppressWarnings("resource")
   ApplicationContext ctx = new ClassPathXmlApplicationContext("/beans.xml");
   JmsTemplate template = (JmsTemplate) ctx.getBean("jmsTemplate");
   Destination destination = (Destination) ctx.getBean("sessionAwareQueueDestination");
   template.send(
       destination,
       new MessageCreator() {
         public Message createMessage(Session session) throws JMSException {
           return session.createTextMessage("Send the message for the SessionAwareQueue test");
         }
       });
   System.out.println("JMS Message Sent");
 }
  @Test
  public void testContainerWithDestNameNoCorrelation() throws Exception {
    BeanFactory beanFactory = mock(BeanFactory.class);
    when(beanFactory.containsBean(IntegrationContextUtils.TASK_SCHEDULER_BEAN_NAME))
        .thenReturn(true);
    ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
    scheduler.initialize();
    when(beanFactory.getBean(IntegrationContextUtils.TASK_SCHEDULER_BEAN_NAME, TaskScheduler.class))
        .thenReturn(scheduler);
    final JmsOutboundGateway gateway = new JmsOutboundGateway();
    gateway.setBeanFactory(beanFactory);
    gateway.setConnectionFactory(getConnectionFactory());
    gateway.setRequestDestination(requestQueue4);
    gateway.setReplyDestinationName("reply4");
    gateway.setUseReplyContainer(true);
    gateway.afterPropertiesSet();
    gateway.start();
    final AtomicReference<Object> reply = new AtomicReference<Object>();
    final CountDownLatch latch1 = new CountDownLatch(1);
    final CountDownLatch latch2 = new CountDownLatch(1);
    Executors.newSingleThreadExecutor()
        .execute(
            () -> {
              latch1.countDown();
              try {
                reply.set(gateway.handleRequestMessage(new GenericMessage<String>("foo")));
              } finally {
                latch2.countDown();
              }
            });
    assertTrue(latch1.await(10, TimeUnit.SECONDS));
    JmsTemplate template = new JmsTemplate();
    template.setConnectionFactory(getConnectionFactory());
    template.setReceiveTimeout(10000);
    javax.jms.Message request = template.receive(requestQueue4);
    assertNotNull(request);
    final javax.jms.Message jmsReply = request;
    template.send(
        request.getJMSReplyTo(),
        (MessageCreator)
            session -> {
              jmsReply.setJMSCorrelationID(jmsReply.getJMSMessageID());
              return jmsReply;
            });
    assertTrue(latch2.await(10, TimeUnit.SECONDS));
    assertNotNull(reply.get());

    gateway.stop();
    scheduler.destroy();
  }
 @Test
 public void testActiveMQOverriddenPoolAndRemoteServer() {
   load(
       TestConfiguration.class,
       "spring.activemq.pooled:true",
       "spring.activemq.brokerUrl:tcp://remote-host:10000");
   JmsTemplate jmsTemplate = this.context.getBean(JmsTemplate.class);
   PooledConnectionFactory pool = this.context.getBean(PooledConnectionFactory.class);
   assertThat(jmsTemplate).isNotNull();
   assertThat(pool).isNotNull();
   assertThat(pool).isEqualTo(jmsTemplate.getConnectionFactory());
   ActiveMQConnectionFactory factory = (ActiveMQConnectionFactory) pool.getConnectionFactory();
   assertThat(factory.getBrokerURL()).isEqualTo("tcp://remote-host:10000");
 }
  /**
   * Creates a {@link org.springframework.jms.core.JmsOperations} object used for request/response
   * using a request timeout value
   */
  public JmsOperations createInOutTemplate(
      JmsEndpoint endpoint, boolean pubSubDomain, String destination, long requestTimeout) {
    JmsOperations answer = createInOnlyTemplate(endpoint, pubSubDomain, destination);
    if (answer instanceof JmsTemplate && requestTimeout > 0) {
      JmsTemplate jmsTemplate = (JmsTemplate) answer;
      jmsTemplate.setExplicitQosEnabled(true);

      // prefer to use timeToLive over requestTimeout if both specified
      long ttl = timeToLive > 0 ? timeToLive : requestTimeout;
      if (ttl > 0 && !isDisableTimeToLive()) {
        // only use TTL if not disabled
        jmsTemplate.setTimeToLive(ttl);
      }

      jmsTemplate.setSessionTransacted(isTransactedInOut());
      if (isTransactedInOut()) {
        jmsTemplate.setSessionAcknowledgeMode(Session.SESSION_TRANSACTED);
      } else {
        if (acknowledgementMode >= 0) {
          jmsTemplate.setSessionAcknowledgeMode(acknowledgementMode);
        } else if (acknowledgementModeName != null) {
          jmsTemplate.setSessionAcknowledgeModeName(acknowledgementModeName);
        } else {
          // default to AUTO
          jmsTemplate.setSessionAcknowledgeMode(Session.AUTO_ACKNOWLEDGE);
        }
      }
    }
    return answer;
  }