Java Code Examples for javax.jms.JMSException#getMessage()

/**
 * Build a descriptive exception message for the given JMSException,
 * incorporating a linked exception's message if appropriate.
 * @param ex the JMSException to build a message for
 * @return the descriptive message String
 * @see javax.jms.JMSException#getLinkedException()
 */
public static String buildExceptionMessage(JMSException ex) {
	String message = ex.getMessage();
	Exception linkedEx = ex.getLinkedException();
	if (linkedEx != null) {
		if (message == null) {
			message = linkedEx.toString();
		}
		else {
			String linkedMessage = linkedEx.getMessage();
			if (linkedMessage != null && !message.contains(linkedMessage)) {
				message = message + "; nested exception is " + linkedEx;
			}
		}
	}
	return message;
}
 

@Test(timeout = 20_000)
public void testConfigureFutureFactoryFromURITypeUnknown() throws Exception {
    try (TestAmqpPeer testPeer = new TestAmqpPeer();) {
        // Ignore errors from peer close due to not sending any Open / Close frames
        testPeer.setSuppressReadExceptionOnClose(true);

        String uri = "amqp://127.0.0.1:" + testPeer.getServerPort() + "?provider.futureType=unknown";

        JmsConnectionFactory factory = new JmsConnectionFactory(uri);

        try {
            factory.createConnection();
            fail("Should not allow a connection to proceed with a bad future factory type");
        } catch (JMSException ex) {
            String message = ex.getMessage();
            assertTrue(message.contains("No ProviderFuture implementation"));
        }

        testPeer.waitForAllHandlersToCompleteNoAssert(1000);
    }
}
 

/**
 * Build a descriptive exception message for the given JMSException,
 * incorporating a linked exception's message if appropriate.
 * @param ex the JMSException to build a message for
 * @return the descriptive message String
 * @see javax.jms.JMSException#getLinkedException()
 */
public static String buildExceptionMessage(JMSException ex) {
	String message = ex.getMessage();
	Exception linkedEx = ex.getLinkedException();
	if (linkedEx != null) {
		if (message == null) {
			message = linkedEx.toString();
		}
		else {
			String linkedMessage = linkedEx.getMessage();
			if (linkedMessage != null && !message.contains(linkedMessage)) {
				message = message + "; nested exception is " + linkedEx;
			}
		}
	}
	return message;
}
 

@Test(timeout = 30000)
public void testNonSslWebSocketConnectionFailsToSslServer() throws Exception {
    TransportOptions serverOptions = new TransportOptions();
    serverOptions.setKeyStoreLocation(BROKER_JKS_KEYSTORE);
    serverOptions.setKeyStorePassword(PASSWORD);
    serverOptions.setVerifyHost(false);

    try (NettySimpleAmqpServer server = new NettySimpleAmqpServer(serverOptions, true, false, true)) {
        server.start();

        JmsConnectionFactory factory = new JmsConnectionFactory("amqpws://localhost:" + server.getServerPort());

        try {
            factory.createConnection();
            fail("should not have connected");
        }
        catch (JMSException jmse) {
            String message = jmse.getMessage();
            assertNotNull(message);
            assertTrue("Unexpected message: " + message, message.contains("Connection failed"));
        }
    }
}
 

/**
 * Fetch a text or binary message from the JMS queue and use the correct
 * deserializer for the received message.
 *
 * @return One new IMonitoringRecord
 *
 * @throws ConnectorDataTransmissionException
 *             if the message type is neither binary nor text, or if a
 *             JMSException occurs
 * @throws ConnectorEndOfDataException
 *             if the received message is null indicating that the consumer is
 *             closed
 */
@Override
public IMonitoringRecord deserializeNextRecord()
		throws ConnectorDataTransmissionException, ConnectorEndOfDataException {
	final Message message;
	try {
		message = this.consumer.receive();
		if (message != null) {
			if (message instanceof BytesMessage) {
				return this.deserialize((BytesMessage) message);
			} else if (message instanceof TextMessage) {
				return this.deserialize(((TextMessage) message).getText());
			} else {
				throw new ConnectorDataTransmissionException(
						"Unsupported message type " + message.getClass().getCanonicalName());
			}
		} else {
			throw new ConnectorEndOfDataException("No more records in the queue");
		}
	} catch (final JMSException e) {
		throw new ConnectorDataTransmissionException(e.getMessage(), e);
	}

}
 

@Test(timeout = 30000)
public void testWebsocketConnectionToBlackHoleServerTimesOut() throws Exception {
    TransportOptions serverOptions = new TransportOptions();

    try (NettyBlackHoleServer server = new NettyBlackHoleServer(serverOptions, false)) {
        server.start();

        JmsConnectionFactory factory = new JmsConnectionFactory("amqpws://localhost:" + server.getServerPort() + "?transport.connectTimeout=25");

        try {
            factory.createConnection();
            fail("should not have connected");
        }
        catch (JMSException jmse) {
            String message = jmse.getMessage();
            assertNotNull(message);
            assertTrue("Unexpected message: " + message, message.contains("WebSocket handshake timed out"));
        }
    }
}
 

@Override
public JMSProducer setDeliveryDelay(long deliveryDelay) {
   try {
      producer.setDeliveryDelay(deliveryDelay);
      return this;
   } catch (JMSException e) {
      JMSRuntimeException e2 = new JMSRuntimeException(e.getMessage());
      e2.initCause(e);
      throw e2;
   }
}
 

@Override
public long getTimeToLive() {
   long timeToLive = 0;
   try {
      timeToLive = producer.getTimeToLive();
      return timeToLive;
   } catch (JMSException e) {
      JMSRuntimeException e2 = new JMSRuntimeException(e.getMessage());
      e2.initCause(e);
      throw e2;
   }
}
 

@Override
public JMSProducer setTimeToLive(long timeToLive) {
   try {
      producer.setTimeToLive(timeToLive);
      return this;
   } catch (JMSException e) {
      JMSRuntimeException e2 = new JMSRuntimeException(e.getMessage());
      e2.initCause(e);
      throw e2;
   }
}
 

@Override
public JMSProducer setPriority(int priority) {
   try {
      producer.setPriority(priority);
   } catch (JMSException e) {
      JMSRuntimeException e2 = new JMSRuntimeException(e.getMessage());
      e2.initCause(e);
      throw e2;
   }
   return this;
}
 

@Override
public int getDeliveryMode() {
   try {
      return producer.getDeliveryMode();
   } catch (JMSException e) {
      JMSRuntimeException e2 = new JMSRuntimeException(e.getMessage());
      e2.initCause(e);
      throw e2;
   }
}
 

@Override
public JMSProducer send(final Destination destination, final Map<String, Object> body) {
    final MapMessage message = wrap(context.createMapMessage());
    if (body != null) {
        try {
            for (final Map.Entry<String, Object> entry : body.entrySet()) {
                final String name = entry.getKey();
                final Object v = entry.getValue();
                if (v instanceof String) {
                    message.setString(name, (String) v);
                } else if (v instanceof Long) {
                    message.setLong(name, (Long) v);
                } else if (v instanceof Double) {
                    message.setDouble(name, (Double) v);
                } else if (v instanceof Integer) {
                    message.setInt(name, (Integer) v);
                } else if (v instanceof Character) {
                    message.setChar(name, (Character) v);
                } else if (v instanceof Short) {
                    message.setShort(name, (Short) v);
                } else if (v instanceof Boolean) {
                    message.setBoolean(name, (Boolean) v);
                } else if (v instanceof Float) {
                    message.setFloat(name, (Float) v);
                } else if (v instanceof Byte) {
                    message.setByte(name, (Byte) v);
                } else if (v instanceof byte[]) {
                    byte[] array = (byte[]) v;
                    message.setBytes(name, array, 0, array.length);
                } else {
                    message.setObject(name, v);
                }
            }
        } catch (final JMSException e) {
            throw new MessageFormatRuntimeException(e.getMessage());
        }
    }
    send(destination, message);
    return this;
}
 

@Override
public int getDeliveryMode() {
    try {
        return producer.getDeliveryMode();
    } catch (final JMSException e) {
        final JMSRuntimeException e2 = new JMSRuntimeException(e.getMessage());
        e2.initCause(e);
        throw e2;
    }
}
 

@Override
public JMSProducer setPriority(final int priority) {
    try {
        producer.setPriority(priority);
    } catch (final JMSException e) {
        final JMSRuntimeException e2 = new JMSRuntimeException(e.getMessage());
        e2.initCause(e);
        throw e2;
    }
    return this;
}
 

void should_set_error(JMSRunnable send) {
  String message;
  try {
    send.run();
    throw new AssertionError("expected to throw");
  } catch (JMSException e) {
    message = e.getMessage();
  }

  testSpanHandler.takeRemoteSpanWithErrorMessage(PRODUCER, message);
}
 

@Override
public JMSProducer setDeliveryDelay(final long deliveryDelay) {
    try {
        producer.setDeliveryDelay(deliveryDelay);
        return this;
    } catch (final JMSException e) {
        JMSRuntimeException e2 = new JMSRuntimeException(e.getMessage());
        e2.initCause(e);
        throw e2;
    }
}
 

/**
 * Wraps a {@link JmsExceptionThrowingBiConsumer} returning a BiConsumer by converting thrown {@link JMSException}s
 * to {@link JMSRuntimeException}s.
 *
 * @param throwingConsumer the JmsExceptionThrowingBiConsumer that throws {@link JMSException}
 * @return a BiConsumer that throws {@link JMSRuntimeException}
 */
static <T> BiConsumer<Message, T> wrap(final JmsExceptionThrowingBiConsumer<T> throwingConsumer) {
    return (m, v) -> {
        try {
            throwingConsumer.accept(m, v);
        } catch (final JMSException jmsException) {
            throw new JMSRuntimeException(jmsException.getMessage(), jmsException.getErrorCode(),
                    jmsException.getCause());
        }
    };
}
 

/**
 * Wraps a {@link org.eclipse.ditto.services.connectivity.messaging.amqp.JmsExceptionThrowingFunction} returning
 * a function by converting thrown {@link javax.jms.JMSException} to {@link javax.jms.JMSRuntimeException}.
 *
 * @param throwingFunction the JmsExceptionThrowingBiConsumer that throws {@link javax.jms.JMSException}
 * @param <T> type of results.
 * @return a function that throws {@link javax.jms.JMSRuntimeException}
 */
static <T> Function<Message, T> wrap(final JmsExceptionThrowingFunction<T> throwingFunction) {
    return (m) -> {
        try {
            return throwingFunction.apply(m);
        } catch (final JMSException jmsException) {
            throw new JMSRuntimeException(jmsException.getMessage(), jmsException.getErrorCode(),
                    jmsException.getCause());
        }
    };
}
 

@SuppressWarnings("unchecked")
@Override
protected <T> T doGetBody(Class<T> asType) throws JMSException {
    try {
        return (T) getObject();
    } catch (JMSException e) {
        throw new MessageFormatException("Failed to read Object: " + e.getMessage());
    }
}
 

/**
 * Setup the connection.
 *
 * @throws ResourceException Thrown if a connection couldn't be created
 */
private void setup() throws ResourceException {
   if (logger.isTraceEnabled()) {
      ActiveMQRALogger.LOGGER.trace("setup()");
   }

   try {

      createCF();

      boolean transacted = cri.isTransacted();
      int acknowledgeMode = Session.AUTO_ACKNOWLEDGE;
      if (cri.getType() == ActiveMQRAConnectionFactory.TOPIC_CONNECTION) {
         if (userName != null && password != null) {
            connection = (ActiveMQXAConnection) connectionFactory.createXATopicConnection(userName, password);
         } else {
            connection = (ActiveMQXAConnection) connectionFactory.createXATopicConnection();
         }

         connection.setExceptionListener(this);

         xaSession = connection.createXATopicSession();
         nonXAsession = connection.createNonXATopicSession(transacted, acknowledgeMode);

      } else if (cri.getType() == ActiveMQRAConnectionFactory.QUEUE_CONNECTION) {
         if (userName != null && password != null) {
            connection = (ActiveMQXAConnection) connectionFactory.createXAQueueConnection(userName, password);
         } else {
            connection = (ActiveMQXAConnection) connectionFactory.createXAQueueConnection();
         }

         connection.setExceptionListener(this);

         xaSession = connection.createXAQueueSession();
         nonXAsession = connection.createNonXAQueueSession(transacted, acknowledgeMode);

      } else {
         if (userName != null && password != null) {
            connection = (ActiveMQXAConnection) connectionFactory.createXAConnection(userName, password);
         } else {
            connection = (ActiveMQXAConnection) connectionFactory.createXAConnection();
         }

         connection.setExceptionListener(this);

         xaSession = connection.createXASession();
         nonXAsession = connection.createNonXASession(transacted, acknowledgeMode);
      }

   } catch (JMSException je) {
      throw new ResourceException(je.getMessage(), je);
   }
}