public void testNoScheduledRedeliveryOfExpired() throws Exception { startBroker(true); ActiveMQConnection consumerConnection = (ActiveMQConnection) createConnection(); consumerConnection.start(); Session consumerSession = consumerConnection.createSession(false, Session.CLIENT_ACKNOWLEDGE); MessageConsumer consumer = consumerSession.createConsumer(destination); sendMessage(1500); Message message = consumer.receive(1000); assertNotNull("got message", message); // ensure there is another consumer to redispatch to MessageConsumer redeliverConsumer = consumerSession.createConsumer(destination); // allow consumed to expire so it gets redelivered TimeUnit.SECONDS.sleep(2); consumer.close(); // should go to dlq as it has expired // validate DLQ MessageConsumer dlqConsumer = consumerSession.createConsumer( new ActiveMQQueue(SharedDeadLetterStrategy.DEFAULT_DEAD_LETTER_QUEUE_NAME)); Message dlqMessage = dlqConsumer.receive(2000); assertNotNull("Got message from dql", dlqMessage); assertEquals( "message matches", message.getStringProperty("data"), dlqMessage.getStringProperty("data")); }
@Override public void onMessageDo(Message msg) throws Exception { String type = msg.getStringProperty("type"); if (ResmMessageListener.TYPE_OBJECT_SYNC.equals(type)) { TextMessage text = (TextMessage) msg; int id = StringUtil.parseInt(text.getText(), -1); logger.debug("接收到同步消息:资源ID=" + text.getText()); if (id > 0) ServiceManager.getResourceUpdateService().syncResource(id); } else if (ResmMessageListener.TYPE_CACHE_ADD.equals(type)) { ObjectMessage object = (ObjectMessage) msg; String cacheName = msg.getStringProperty("cache"); CacheableObject obj = (CacheableObject) object.getObject(); logger.debug("接收到缓存增加消息:" + cacheName + " " + obj.getClass().getName()); obj.onDeserialize(); obj.dump(); CacheManager.addCache(cacheName, obj); } else if (ResmMessageListener.TYPE_CACHE_REMOVE.equals(type)) { ObjectMessage object = (ObjectMessage) msg; String cacheName = msg.getStringProperty("cache"); CacheableObject obj = (CacheableObject) object.getObject(); logger.debug("接收到缓存删除消息:" + cacheName + " " + obj.getClass().getName()); obj.onDeserialize(); obj.dump(); CacheManager.removeCache(cacheName, obj); } else { System.out.println(msg.toString()); } }
public String send( final T message, final Message correlatedMessage, final String correlationId, final URI dvbEndpointSelector, final String jmsGroupId, final Destination replyQueue) { try { final M jmsMessage = this.messageHandler.createEmptyMessage(this.sessionDelegate); jmsMessage.setJMSCorrelationID(determineCorrelationId(correlationId, correlatedMessage)); Destination replyTo = replyQueue == null ? this.defaultReplyDestinationDelegate.delegate() : replyQueue; if (replyTo != null) { jmsMessage.setJMSReplyTo(replyTo); } final URI temp = DataUtilities.coalesce(dvbEndpointSelector, this.defaultEndpoint); if (temp != null) { jmsMessage.setStringProperty( JMSMessageSender.ENDPOINT_NAMESPACE, dvbEndpointSelector.toASCIIString()); } if (correlatedMessage != null && this.copyPropertyPattern != null) { //noinspection unchecked for (final String name : Collections.list((Enumeration<String>) correlatedMessage.getPropertyNames())) { if (this.copyPropertyPattern.matcher(name).matches()) { if (correlatedMessage.getStringProperty(name) != null) { jmsMessage.setStringProperty(name, correlatedMessage.getStringProperty(name)); } else { jmsMessage.setObjectProperty(name, correlatedMessage.getObjectProperty(name)); } } } } this.messageHandler.fillMessage(message, jmsMessage); if (jmsGroupId != null) { jmsMessage.setStringProperty(JMSMessageSender.JMSX_GROUP_ID, jmsGroupId); } Delegate<MessageProducer> producer = this.producerDelegate; if (correlatedMessage != null && correlatedMessage.getJMSReplyTo() != null) { producer = new JMSMessageProducerDelegate( sessionDelegate, new UnmodifiableDelegate<>(correlatedMessage.getJMSReplyTo())); } producer.delegate().send(jmsMessage); return jmsMessage.getJMSMessageID(); } catch (final JMSException e) { throw DelegatedException.delegate(e); } }
static Map<String, Set<String>> get(final Message msg, final String prefix) throws JMSException { String regexSafeDelimiter = Pattern.quote(DELIMITER); final Map<String, Set<String>> map = new HashMap<String, Set<String>>(); final Enumeration names = msg.getPropertyNames(); while (names.hasMoreElements()) { final String name = names.nextElement().toString(); final String value = msg.getStringProperty(name); if (name.startsWith(prefix) && name.endsWith(COPY) == false) { final String property = msg.getStringProperty(name + COPY); if (property != null) { map.put(value, new HashSet<String>(Arrays.asList(property.split(regexSafeDelimiter)))); } } } return map; }
public void invalidateObject(Session session, javax.jms.Message msg) throws javax.jms.JMSException { String tableName = msg.getStringProperty("TABLE"); if (tableName == null) { return; } Class baseClass = (Class) tableNameToClass.get(tableName); if (baseClass == null) { return; } Vector pkFieldNames = (Vector) tableNameToPkFieldNames.get(tableName); if (pkFieldNames == null) { return; } // create DatabaseRecord corresponding to the message DatabaseRecord row = new DatabaseRecord(pkFieldNames.size()); for (int i = 0; i < pkFieldNames.size(); i++) { String fieldName = (String) pkFieldNames.elementAt(i); Object value = msg.getObjectProperty(fieldName); row.put(fieldName, value); } // invalidate in TopLink cache the object corresponding to the row and the baseClass session.getIdentityMapAccessor().invalidateObject(row, baseClass); }
/** * @param type * @param clazz * @param bool * @throws JMSException */ private void bodyAssignableFrom(final JmsMessageType type, final boolean bool, Class... clazz) throws JMSException { Assert.assertNotNull("clazz!=null", clazz); Assert.assertTrue("clazz[] not empty", clazz.length > 0); Object body = createBodySendAndReceive(type); Message msg = queueConsumer.receive(500); Assert.assertNotNull("must have a msg", msg); Assert.assertEquals(type.toString(), msg.getStringProperty("type")); for (Class<?> c : clazz) { Assert.assertEquals( msg + " " + type + " & " + c + ": " + bool, bool, msg.isBodyAssignableTo(c)); if (bool) { Object receivedBody = msg.getBody(c); Assert.assertTrue("correct type " + c, c.isInstance(receivedBody)); if (body.getClass().isAssignableFrom(byte[].class)) { Arrays.equals((byte[]) body, (byte[]) receivedBody); } else { Assert.assertEquals( "clazz=" + c + ", bodies must match.. " + body.equals(receivedBody), body, receivedBody); } } else { try { Object foo = msg.getBody(c); Assert.fail("expected a " + MessageFormatException.class); } catch (MessageFormatException e) { // expected } } } }
public static String getSourceFPSName(Message message) throws JMSException { if (!message.propertyExists(MessagePropertyNames.SOURCE)) { return SOURCE_FPS_NAME_DEF; } return message.getStringProperty(MessagePropertyNames.SOURCE); }
@Override public void onMessage(Message msg) { try { if (!msg.propertyExists(AppConsts.MESSAGE_TYPE) || !(msg instanceof TextMessage)) { throw new IOError(null); } String type = msg.getStringProperty(AppConsts.MESSAGE_TYPE); if (type.equals(AppConsts.CHANGE_BALANCE_MT)) { String text = ((TextMessage) msg).getText(); ChangeBalanceDTO dto = null; try { dto = ju.fromXml(text, ChangeBalanceDTO.class); } catch (Exception e) { log.error("Could not convert xml to object", e); throw new IOError(null); } if (db.changeBalance(dto.getPhoneNumber(), dto.getDelta()) == null) { throw new IOError(null); } } else { throw new IOError(null); } } catch (IOError e) { forwardMessageToNone(msg); } catch (JMSException e) { log.trace(e.getMessage(), e); } }
private void addMessageIDInHeader(final Message msg) throws Exception { // We concatenate the old message id as a header in the message // This allows the target to then use this as the JMSCorrelationID of any response message // thus enabling a distributed request-response pattern. // Each bridge (if there are more than one) in the chain can concatenate the message id // So in the case of multiple bridges having routed the message this can be used in a multi-hop // distributed request/response if (JMSBridgeImpl.trace) { HornetQJMSServerLogger.LOGGER.trace("Adding old message id in Message header"); } JMSBridgeImpl.copyProperties(msg); String val = null; val = msg.getStringProperty(HornetQJMSConstants.JBOSS_MESSAGING_BRIDGE_MESSAGE_ID_LIST); if (val == null) { val = msg.getJMSMessageID(); } else { StringBuffer sb = new StringBuffer(val); sb.append(",").append(msg.getJMSMessageID()); val = sb.toString(); } msg.setStringProperty(HornetQJMSConstants.JBOSS_MESSAGING_BRIDGE_MESSAGE_ID_LIST, val); }
public static String getUserDefinedId(Message message) throws JMSException { if (!message.propertyExists(MessagePropertyNames.USER_DEFINED_DOC_ID)) { return USER_DEFINED_DOC_ID_DEF; } return message.getStringProperty(MessagePropertyNames.USER_DEFINED_DOC_ID); }
public static final void printMessageHeaders(Message pMessge, Object pHandler) { StringWriter stringWriter = new StringWriter(); PrintWriter writer = new PrintWriter(stringWriter); try { writer.println("==================================================="); writer.println("MDB Event Handler class=[" + pHandler.getClass().getName() + "]"); writer.println(""); writer.println("JMS Message Id: " + pMessge.getJMSMessageID()); for (Enumeration em = pMessge.getPropertyNames(); em.hasMoreElements(); ) { String property = (String) em.nextElement(); writer.println( "JMS Prop=[" + property + "] value=[" + pMessge.getStringProperty(property) + "]"); } writer.println("==================================================="); } catch (JMSException e) { e.printStackTrace(); } writer.flush(); System.out.println(stringWriter.toString()); }
public static String getEventProcessVersion(Message message) throws JMSException { if (!message.propertyExists(MessagePropertyNames.EVENT_PROCESS_VERSION)) { return EVENT_PROCESS_VERSION_DEF; } return message.getStringProperty(MessagePropertyNames.EVENT_PROCESS_VERSION); }
public static String getEventStatus(Message message) throws JMSException { if (!message.propertyExists(MessagePropertyNames.EVENT_STATUS)) { return EVENT_STATUS_DEF; } return message.getStringProperty(MessagePropertyNames.EVENT_STATUS); }
public static String getCompInstName(Message message) throws JMSException { if (!message.propertyExists(MessagePropertyNames.COMP_INST_NAME)) { return COMP_INST_NAME_DEF; } return message.getStringProperty(MessagePropertyNames.COMP_INST_NAME); }
public static String getEventProcessName(Message message) throws JMSException { if (!message.propertyExists(MessagePropertyNames.EVENT_PROCESS_NAME)) { return EVENT_PROCESS_NAME_DEF; } return message.getStringProperty(MessagePropertyNames.EVENT_PROCESS_NAME); }
@Override public void onMessage(Message message) { if (!(message instanceof ObjectMessage)) { return; } try { Object objectInMessage = ((ObjectMessage) message).getObject(); if (!(objectInMessage instanceof LectureWrapperDTO)) { return; } final String messageAction = message.getStringProperty("action"); if (messageAction == null) { return; } LectureWrapperDTO lectureWrapperDTO = (LectureWrapperDTO) objectInMessage; if (messageAction.equals(ISchedulerListener.InfoType.CREATED.toString())) { schedulerListener.notify(ISchedulerListener.InfoType.CREATED, lectureWrapperDTO); } else if (messageAction.equals(ISchedulerListener.InfoType.INFO.toString())) { schedulerListener.notify(ISchedulerListener.InfoType.INFO, lectureWrapperDTO); } else if (messageAction.equals(ISchedulerListener.InfoType.DENIED.toString())) { schedulerListener.notify(ISchedulerListener.InfoType.DENIED, lectureWrapperDTO); } else if (messageAction.equals(ISchedulerListener.InfoType.STREAMED.toString())) { schedulerListener.notify(ISchedulerListener.InfoType.STREAMED, lectureWrapperDTO); } } catch (JMSException e) { e.printStackTrace(); } }
public static String getSink(Message message) throws JMSException { if (!message.propertyExists(MessagePropertyNames.SINK)) { return null; } return message.getStringProperty(MessagePropertyNames.SINK); }
public static String getComment(Message message) throws JMSException { if (!message.propertyExists(MessagePropertyNames.COMMENT)) { return COMMENT_DEF; } return message.getStringProperty(MessagePropertyNames.COMMENT); }
@Override protected String extractString(JMSBindingData binding) throws Exception { Message content = binding.getMessage(); if (content instanceof TextMessage) { return TextMessage.class.cast(content).getText(); } else if (content instanceof BytesMessage) { BytesMessage sourceBytes = BytesMessage.class.cast(content); if (sourceBytes.getBodyLength() > Integer.MAX_VALUE) { throw JCAMessages.MESSAGES .theSizeOfMessageContentExceedsBytesThatIsNotSupportedByThisOperationSelector( "" + Integer.MAX_VALUE); } byte[] bytearr = new byte[(int) sourceBytes.getBodyLength()]; sourceBytes.readBytes(bytearr); return new String(bytearr); } else if (content instanceof ObjectMessage) { ObjectMessage sourceObj = ObjectMessage.class.cast(content); return String.class.cast(sourceObj.getObject()); } else if (content instanceof MapMessage) { MapMessage sourceMap = MapMessage.class.cast(content); return sourceMap.getString(KEY); } else { return content.getStringProperty(KEY); } }
public static String getPortName(Message message) throws JMSException { if (!message.propertyExists(MessagePropertyNames.PORT_NAME)) { return PORT_NAME_DEF; } return message.getStringProperty(MessagePropertyNames.PORT_NAME); }
public static String getDocumentID(Message message) throws JMSException { if (!message.propertyExists(MessagePropertyNames.DOCUMENT_ID)) { return DOCUMENT_ID_DEF; } return message.getStringProperty(MessagePropertyNames.DOCUMENT_ID); }
public static String getEventDescription(Message message) throws JMSException { if (!message.propertyExists(MessagePropertyNames.EVENT_DESCRIPTION)) { return EVENT_DESCRIPTION_DEF; } return message.getStringProperty(MessagePropertyNames.EVENT_DESCRIPTION); }
public static String getEventCategory(Message message) throws JMSException { if (!message.propertyExists(MessagePropertyNames.EVENT_CATEGORY)) { return EVENT_MODULE_DEF; } return message.getStringProperty(MessagePropertyNames.EVENT_CATEGORY); }
public static String getWorkFlowInstId(Message message) throws JMSException { if (!message.propertyExists(MessagePropertyNames.WORK_FLOW_INST_ID)) { return WORK_FLOW_INST_ID_DEF; } return message.getStringProperty(MessagePropertyNames.WORK_FLOW_INST_ID); }
/** * {@inheritDoc} * * @see javax.jms.MessageListener#onMessage(javax.jms.Message) */ public void onMessage(Message message) { try { String fromServer = message.getStringProperty(ClusterTrackingService.EVENT_FROM_SERVER); String toServer = message.getStringProperty(ClusterTrackingService.EVENT_TO_SERVER); String trackingCookie = message.getStringProperty(ClusterTrackingService.EVENT_TRACKING_COOKIE); String remoteUser = message.getStringProperty(ClusterTrackingService.EVENT_USER); LOGGER.info( "Started handling cluster user jms message. from:{} to:{} cookie:{} user:{}", new Object[] {fromServer, toServer, trackingCookie, remoteUser}); clusterTrackingServiceImpl.pingTracking(trackingCookie, remoteUser, false); } catch (PingRemoteTrackingFailedException e) { LOGGER.error(e.getMessage()); } catch (JMSException e) { LOGGER.error(e.getMessage(), e); } }
@Override public void onMessage(Message message) { try { log.info("pms heart beat receive :" + message.getStringProperty("messageType")); } catch (JMSException e) { e.printStackTrace(); } }
/** * Get property * * @param name The name * @return The value * @throws JMSException Thrown if an error occurs */ @Override public String getStringProperty(final String name) throws JMSException { if (ActiveMQRAMessage.trace) { ActiveMQRALogger.LOGGER.trace("getStringProperty(" + name + ")"); } return message.getStringProperty(name); }
private List<Message> filterForEvent(GameEvent event) throws JMSException { ArrayList ret = new ArrayList(); List<Message> ml = mockTopic.getReceivedMessageList(); for (Message msg : ml) { if (msg.getStringProperty("GAME_EVENT").equals(event.name())) ret.add(msg); } return ret; }
@Override public void run() { try { int count = 0; // Keep reading as long as it hasn't been told to shutdown while (!shutdown) { if (idList.size() >= totalToExpect) { LOG.info("Got {} for q: {}", +idList.size(), qName); session.commit(); break; } Message m = mc.receive(4000); if (m != null) { // We received a non-null message, add the ID to our list idList.add(m.getStringProperty("KEY")); count++; // If we've reached our batch size, commit the batch and reset the count if (count == batchSize) { session.commit(); count = 0; } } else { // We didn't receive anything this time, commit any current batch and reset the count session.commit(); count = 0; // Sleep a little before trying to read after not getting a message try { if (idList.size() < totalToExpect) { LOG.info("did not receive on {}, current count: {}", qName, idList.size()); } // sleep(3000); } catch (Exception e) { } } } } catch (Exception e) { e.printStackTrace(); } finally { // Once we exit, close everything close(); } }
public static void constructConnectorMessageProperties( Message jmsMsg, CustomMessagePropertyList customMessagePropertyList) throws JMSException { List<CustomMessageProperty> customMessageProperties = customMessagePropertyList.getCustomMessageProperty(); int index = 0; while (index < JMSConstants.ARR_CUSTOM_PROPS.length) { if (jmsMsg.getStringProperty(JMSConstants.ARR_CUSTOM_PROPS[index]) != null && jmsMsg.getStringProperty(JMSConstants.ARR_CUSTOM_PROPS[index]).isEmpty()) { CustomMessageProperty customMessageProperty = new CustomMessageProperty(); customMessageProperty.setName(JMSConstants.ARR_CUSTOM_PROPS[index]); customMessageProperty.setValue( jmsMsg.getStringProperty(JMSConstants.ARR_CUSTOM_PROPS[index])); customMessageProperties.add(customMessageProperty); index++; } } }