Example #1
0
  @Test
  public void sendToNonExistantDestination() throws Exception {
    Destination destination = HornetQJMSClient.createQueue("DoesNotExist");
    TransportConfiguration transportConfiguration =
        new TransportConfiguration(InVMConnectorFactory.class.getName());
    ConnectionFactory localConnectionFactory =
        HornetQJMSClient.createConnectionFactoryWithoutHA(
            JMSFactoryType.CF, transportConfiguration);
    // Using JMS 1 API
    Connection connection = localConnectionFactory.createConnection();
    Session session = connection.createSession();
    try {
      MessageProducer messageProducer = session.createProducer(null);
      messageProducer.send(destination, session.createMessage());
      Assert.fail("Succeeded in sending message to a non-existant destination using JMS 1 API!");
    } catch (JMSException e) { // Expected }

    }

    // Using JMS 2 API
    JMSContext context = localConnectionFactory.createContext();
    JMSProducer jmsProducer = context.createProducer().setDeliveryMode(DeliveryMode.PERSISTENT);

    try {
      jmsProducer.send(destination, context.createMessage());
      Assert.fail("Succeeded in sending message to a non-existant destination using JMS 2 API!");
    } catch (JMSRuntimeException e) { // Expected }
    }
  }
Example #2
0
  @Test
  public void testDelay() throws Exception {
    JMSProducer producer = context.createProducer();

    JMSConsumer consumer = context.createConsumer(queue1);

    producer.setDeliveryDelay(500);

    long timeStart = System.currentTimeMillis();

    String strRandom = newXID().toString();

    producer.send(queue1, context.createTextMessage(strRandom));

    TextMessage msg = (TextMessage) consumer.receive(2500);

    assertNotNull(msg);

    long actualDelay = System.currentTimeMillis() - timeStart;
    assertTrue(
        "delay is not working, actualDelay=" + actualDelay,
        actualDelay >= 500 && actualDelay < 2000);

    assertEquals(strRandom, msg.getText());
  }
  @Test
  public void testCreateContextClientAckSession() throws Exception {

    JMSContext context = jms2ConnectionFactory.createContext(JMSContext.CLIENT_ACKNOWLEDGE);
    assertNotNull(context);
    assertEquals(Jms2Context.class, context.getClass());
  }
  @Override
  @After
  public void tearDown() throws Exception {
    try {
      for (JMSContext jmsContext : contextSet) {
        jmsContext.close();
      }
    } catch (RuntimeException ignored) {
      // no-op
    } finally {
      contextSet.clear();
    }
    try {
      if (conn != null) conn.close();
    } catch (Exception e) {
      // no-op
    }

    namingContext.close();
    jmsServer.stop();
    server = null;
    cf = null;
    jmsServer = null;

    namingContext = null;

    MBeanServerFactory.releaseMBeanServer(mbeanServer);

    mbeanServer = null;

    ServiceUtils.setTransactionManager(null);

    super.tearDown();
  }
  @Test
  public void testCreateTransactedSession() throws Exception {

    JMSContext context = jms2ConnectionFactory.createContext(JMSContext.SESSION_TRANSACTED);
    assertNotNull(context);
    assertEquals(Jms2Context.class, context.getClass());
  }
  @Test
  public void createContext() throws Exception {

    JMSContext context = jms2ConnectionFactory.createContext();
    assertNotNull(context);
    assertEquals(Jms2Context.class, context.getClass());
  }
 public void onMetricsServiceReady(@Observes @ServiceReady ServiceReadyEvent event) {
   context = connectionFactory.createContext();
   gaugesConsumer = context.createConsumer(gaugesQueue);
   gaugesConsumer.setMessageListener(
       new BasicMessageListener<MetricDataMessage>() {
         @Override
         protected void onBasicMessage(MetricDataMessage basicMessage) {
           onGaugeData(basicMessage.getMetricData());
         }
       });
   countersConsumer = context.createConsumer(countersQueue);
   countersConsumer.setMessageListener(
       new BasicMessageListener<MetricDataMessage>() {
         @Override
         protected void onBasicMessage(MetricDataMessage basicMessage) {
           onCounterData(basicMessage.getMetricData());
         }
       });
   availabilityConsumer = context.createConsumer(availabilityQueue);
   availabilityConsumer.setMessageListener(
       new BasicMessageListener<AvailDataMessage>() {
         @Override
         protected void onBasicMessage(AvailDataMessage basicMessage) {
           onAvailData(basicMessage.getAvailData());
         }
       });
 }
Example #8
0
 @Test
 public void testSendStreamMessage() throws JMSException, InterruptedException {
   JmsProducerCompletionListenerTest.CountingCompletionListener cl =
       new JmsProducerCompletionListenerTest.CountingCompletionListener(1);
   JMSProducer producer = context.createProducer();
   producer.setAsync(cl);
   StreamMessage msg = context.createStreamMessage();
   msg.setStringProperty("name", name.getMethodName());
   String bprop = "booleanProp";
   String iprop = "intProp";
   msg.setBooleanProperty(bprop, true);
   msg.setIntProperty(iprop, 42);
   msg.writeBoolean(true);
   msg.writeInt(67);
   producer.send(queue1, msg);
   JMSConsumer consumer = context.createConsumer(queue1);
   Message msg2 = consumer.receive(100);
   Assert.assertNotNull(msg2);
   Assert.assertTrue(cl.completionLatch.await(1, TimeUnit.SECONDS));
   StreamMessage sm = (StreamMessage) cl.lastMessage;
   Assert.assertEquals(true, sm.getBooleanProperty(bprop));
   Assert.assertEquals(42, sm.getIntProperty(iprop));
   Assert.assertEquals(true, sm.readBoolean());
   Assert.assertEquals(67, sm.readInt());
 }
  @Override
  public int doStartTag() throws JspException {
    String context = "";
    try {
      System.out.println("jsp tag start...");

      ut.begin();
      JMSProducer producer = jmsContext.createProducer();
      TextMessage msg = jmsContext.createTextMessage("Hello JSP Tag");
      producer.send(queue, msg);
      context = jmsContext.toString();
      ut.commit();

      if (context.indexOf(transactionScope) == -1) {
        throw new JspException("NOT in transaction scope!");
      }
      // Get the writer object for output.
      JspWriter out = pageContext.getOut();

      // Perform substr operation on string.
      out.println(text);

    } catch (Exception e) {
      throw new JspException(e);
    }
    return SKIP_BODY;
  }
  @Test
  public void testClusteredTopic() throws Exception {

    InitialContext contextFromServer0 = createJNDIContextFromServer0();
    InitialContext contextFromServer1 = createJNDIContextFromServer1();

    try (JMSContext jmsContext0 = createJMSContext(createJNDIContextFromServer0());
        JMSContext jmsContext1 = createJMSContext(createJNDIContextFromServer1())) {
      JMSConsumer consumer0 =
          jmsContext0.createConsumer((Destination) contextFromServer0.lookup(jmsTopicLookup));
      JMSConsumer consumer1 =
          jmsContext1.createConsumer((Destination) contextFromServer1.lookup(jmsTopicLookup));

      String text = UUID.randomUUID().toString();

      // WIP test if the problem is that the view is not yet propagated
      Thread.sleep(ClusteringTestConstants.GRACE_TIME_TO_MEMBERSHIP_CHANGE);

      // send a message to the topic on server 0
      sendMessage(contextFromServer0, jmsTopicLookup, text);
      // consumers receive it on both servers
      receiveMessage(consumer0, text);
      receiveMessage(consumer1, text);

      String anotherText = UUID.randomUUID().toString();
      // send another message to topic on server 1
      sendMessage(contextFromServer1, jmsTopicLookup, anotherText);
      // consumers receive it on both servers
      receiveMessage(consumer0, anotherText);
      receiveMessage(consumer1, anotherText);
    }
  }
Example #11
0
 @Test
 public void testGetClientId() {
   JMSContext context2 = addContext(context.createContext(Session.AUTO_ACKNOWLEDGE));
   final String id = "ID: " + random.nextInt();
   context.setClientID(id);
   Assert.assertEquals(
       "id's must match because the connection is shared", id, context2.getClientID());
 }
Example #12
0
 @Test
 public void testSetGetClientIdNewContext() {
   final String id = "123";
   JMSContext c = context; // createContext();
   c.setClientID(id);
   JMSContext c2 = addContext(c.createContext(Session.CLIENT_ACKNOWLEDGE));
   Assert.assertEquals(id, c2.getClientID());
 }
 @Override
 public void sendMessage(String text) {
   try {
     JMSProducer producer = jmsContext.createProducer();
     TextMessage message = jmsContext.createTextMessage(text);
     producer.send(testQueue, message);
   } catch (Exception e) {
     throw new EJBException(e);
   }
 }
  @Test
  public void testCreateContextCredentialsAndClientAckSession() throws Exception {
    final String username = "******";
    final String password = "******";

    JMSContext context =
        jms2ConnectionFactory.createContext(username, password, JMSContext.CLIENT_ACKNOWLEDGE);
    assertNotNull(context);
    assertEquals(Jms2Context.class, context.getClass());
  }
  /** Envia um objeto complexo para a fila JMS */
  public void enviarObjetoForma2(Aluno aluno) {
    try {
      ObjectMessage objMessage = context.createObjectMessage();
      objMessage.setObject(aluno);
      context.createProducer().send(fila, objMessage);

    } catch (JMSException ex) {
      ex.printStackTrace();
    }
  }
Example #16
0
  @Test
  public void testRollbackTest() {
    JMSContext ctx = addContext(cf.createContext(JMSContext.SESSION_TRANSACTED));

    JMSProducer producer = ctx.createProducer();
    JMSConsumer cons = ctx.createConsumer(queue1);

    producer.send(queue1, context.createTextMessage("hello"));

    ctx.rollback();

    assertNull(cons.receiveNoWait());

    producer.send(queue1, context.createTextMessage("hello"));

    ctx.commit();

    assertNotNull(cons.receiveNoWait());

    ctx.commit();

    ctx.rollback();

    assertNull(cons.receiveNoWait());

    cons.close();
  }
Example #17
0
 @Test
 public void testInvalidDestination() {
   JMSProducer producer = context.createProducer();
   Message msg = context.createMessage();
   try {
     producer.send((Destination) null, msg);
     Assert.fail("null Destination");
   } catch (InvalidDestinationRuntimeException expected) {
     // no-op
   }
 }
  protected static void sendMessage(Context ctx, String destinationLookup, String text)
      throws NamingException {
    ConnectionFactory cf = (ConnectionFactory) ctx.lookup("jms/RemoteConnectionFactory");
    assertNotNull(cf);
    Destination destination = (Destination) ctx.lookup(destinationLookup);
    assertNotNull(destination);

    try (JMSContext context = cf.createContext("guest", "guest")) {
      context.createProducer().send(destination, text);
    }
  }
Example #19
0
 @Test
 public void testSetClientIdLate() {
   JMSProducer producer = context.createProducer();
   Message msg = context.createMessage();
   producer.send(queue1, msg);
   try {
     context.setClientID("id");
     Assert.fail("expected exception");
   } catch (IllegalStateRuntimeException e) {
     // no op
   }
 }
 public void receiveAll() {
   System.out.println("--> Receiving redundant messages ...");
   try {
     QueueBrowser browser = context.createBrowser(myQueue);
     while (browser.getEnumeration().hasMoreElements()) {
       System.out.println("--> here is one");
       context.createConsumer(myQueue).receiveBody(String.class, 1000);
     }
   } catch (JMSException ex) {
     Logger.getLogger(MessageReceiverSync.class.getName()).log(Level.SEVERE, null, ex);
   }
 }
  protected static void receiveMessage(Context ctx, String destinationLookup, String expectedText)
      throws NamingException {
    ConnectionFactory cf = (ConnectionFactory) ctx.lookup("jms/RemoteConnectionFactory");
    assertNotNull(cf);
    Destination destination = (Destination) ctx.lookup(destinationLookup);
    assertNotNull(destination);

    try (JMSContext context = cf.createContext("guest", "guest"); ) {
      JMSConsumer consumer = context.createConsumer(destination);
      receiveMessage(consumer, expectedText);
    }
  }
Example #22
0
  @Test
  public void testSecurityOnJMSContext() throws Exception {

    server.getSecurityManager().addUser("IDo", "Exist");
    try {
      JMSContext ctx = cf.createContext("Idont", "exist");
      ctx.close();
    } catch (JMSSecurityRuntimeException e) {
      // expected
    }
    JMSContext ctx = cf.createContext("IDo", "Exist");
    ctx.close();
    ;
  }
 public static void main(String[] args) throws NamingException {
   final InitialContext ic = new InitialContext();
   ConnectionFactory factory = (ConnectionFactory) ic.lookup("jms/RemoteConnectionFactory");
   Queue queue = (Queue) ic.lookup("jms/FILA.GERADOR");
   try (JMSContext context = factory.createContext("jms", "jms2")) {
     JMSConsumer consumer = context.createConsumer(queue);
     consumer.setMessageListener(new TratadorDeMensagem());
     context.start();
     Scanner teclado = new Scanner(System.in);
     System.out.println("Tratador esperando as mensagens na fila JMS");
     teclado.nextLine();
     teclado.close();
     context.stop();
   }
 }
Example #24
0
  @Test
  public void testCreateQueueConnection() throws Exception {

    server.getSecurityManager().addUser("IDo", "Exist");
    try {
      QueueConnection queueC =
          ((QueueConnectionFactory) cf).createQueueConnection("IDont", "Exist");
      fail("supposed to throw exception");
      queueC.close();
    } catch (JMSSecurityException e) {
      // expected
    }
    JMSContext ctx = cf.createContext("IDo", "Exist");
    ctx.close();
    ;
  }
 public MapMessage convert(BusinessObject bo) throws Exception {
   MapMessage mm = context.createMapMessage();
   for (String key : bo.keySet()) {
     mm.setObject(key, bo.get(key));
   }
   return mm;
 }
Example #26
0
 private void closeContext() {
   try {
     context.close();
   } catch (Throwable t) {
     error = t;
   }
 }
Example #27
0
 private void stopContext() {
   try {
     context.stop();
   } catch (Throwable t) {
     error = t;
   }
 }
 public String receiveMessage() {
   try (JMSConsumer consumer = context.createConsumer(pointsQueue)) {
     String message = consumer.receiveBody(String.class);
     Logger.getLogger(ReceivePointsBean.class.getName())
         .log(Level.INFO, "Received message: " + message);
     return message;
   }
 }
 @Override
 public void onMessage(Message message) {
   JMSProducer producer = context.createProducer();
   try {
     // What we need to do is find classification entries that have not been
     // filled out. When we find them, we send a message to *another* queue,
     // saying "run this classification" - with an expiry of 45 seconds.
     List<Classification> classifications = classificationService.findUnclassifiedEntries();
     for (Classification classification : classifications) {
       ObjectMessage classificationMessage = context.createObjectMessage(classification);
       classificationMessage.setJMSExpiration(45 * 1000);
       producer.send(classificationQueue, classificationMessage);
     }
   } catch (JMSException jmsException) {
     jmsException.printStackTrace();
   }
 }
Example #30
0
  @Test
  public void testReceiveText() throws Exception {
    JMSProducer producer = context.createProducer();

    JMSConsumer consumer = context.createConsumer(queue1);

    String randomStr = newXID().toString();

    System.out.println("RandomStr:" + randomStr);

    TextMessage sendMsg = context.createTextMessage(randomStr);
    producer.send(queue1, sendMsg);

    TextMessage receiveMsg = (TextMessage) consumer.receiveNoWait();

    assertEquals(randomStr, receiveMsg.getText());
  }