/*
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*/
package org.apache.qpid.server.queue;
import org.apache.commons.lang.time.FastDateFormat;
import org.apache.qpid.AMQException;
import org.apache.qpid.framing.AMQShortString;
import org.apache.qpid.framing.BasicContentHeaderProperties;
import org.apache.qpid.framing.ContentBody;
import org.apache.qpid.framing.ContentHeaderBody;
import org.apache.qpid.framing.abstraction.ContentChunk;
import org.apache.qpid.framing.abstraction.MessagePublishInfo;
import org.apache.qpid.management.common.mbeans.ManagedQueue;
import org.apache.qpid.server.AMQChannel;
import org.apache.qpid.server.message.AMQMessage;
import org.apache.qpid.server.message.MessageMetaData;
import org.apache.qpid.server.protocol.InternalTestProtocolSession;
import org.apache.qpid.server.registry.ApplicationRegistry;
import org.apache.qpid.server.store.TestableMemoryMessageStore;
import org.apache.qpid.server.subscription.Subscription;
import org.apache.qpid.server.subscription.SubscriptionFactory;
import org.apache.qpid.server.subscription.SubscriptionFactoryImpl;
import org.apache.qpid.server.util.InternalBrokerBaseCase;
import javax.management.JMException;
import javax.management.openmbean.CompositeData;
import javax.management.openmbean.CompositeDataSupport;
import javax.management.openmbean.TabularData;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
/**
* Test class to test AMQQueueMBean attributes and operations
*/
public class AMQQueueMBeanTest extends InternalBrokerBaseCase
{
private static long MESSAGE_SIZE = 1000;
private AMQQueueMBean _queueMBean;
private static final SubscriptionFactoryImpl SUBSCRIPTION_FACTORY = SubscriptionFactoryImpl.INSTANCE;
public void testMessageCountTransient() throws Exception
{
int messageCount = 10;
sendMessages(messageCount, false);
assertTrue(_queueMBean.getMessageCount() == messageCount);
assertTrue(_queueMBean.getReceivedMessageCount() == messageCount);
long queueDepth = (messageCount * MESSAGE_SIZE);
assertTrue(_queueMBean.getQueueDepth() == queueDepth);
_queueMBean.deleteMessageFromTop();
assertTrue(_queueMBean.getMessageCount() == (messageCount - 1));
assertTrue(_queueMBean.getReceivedMessageCount() == messageCount);
_queueMBean.clearQueue();
assertEquals(0,(int)_queueMBean.getMessageCount());
assertTrue(_queueMBean.getReceivedMessageCount() == messageCount);
//Ensure that the data has been removed from the Store
verifyBrokerState();
}
public void testMessageCountPersistent() throws Exception
{
int messageCount = 10;
sendMessages(messageCount, true);
assertEquals("", messageCount, _queueMBean.getMessageCount().intValue());
assertTrue(_queueMBean.getReceivedMessageCount() == messageCount);
long queueDepth = (messageCount * MESSAGE_SIZE);
assertTrue(_queueMBean.getQueueDepth() == queueDepth);
_queueMBean.deleteMessageFromTop();
assertTrue(_queueMBean.getMessageCount() == (messageCount - 1));
assertTrue(_queueMBean.getReceivedMessageCount() == messageCount);
_queueMBean.clearQueue();
assertTrue(_queueMBean.getMessageCount() == 0);
assertTrue(_queueMBean.getReceivedMessageCount() == messageCount);
//Ensure that the data has been removed from the Store
verifyBrokerState();
}
public void testDeleteMessages() throws Exception
{
int messageCount = 10;
sendMessages(messageCount, true);
assertEquals("", messageCount, _queueMBean.getMessageCount().intValue());
assertTrue(_queueMBean.getReceivedMessageCount() == messageCount);
long queueDepth = (messageCount * MESSAGE_SIZE);
assertTrue(_queueMBean.getQueueDepth() == queueDepth);
//delete first message
_queueMBean.deleteMessages(1L,1L);
assertTrue(_queueMBean.getMessageCount() == (messageCount - 1));
assertTrue(_queueMBean.getReceivedMessageCount() == messageCount);
try
{
_queueMBean.viewMessageContent(1L);
fail("Message should no longer be on the queue");
}
catch(Exception e)
{
}
//delete last message, leaving 2nd to 9th
_queueMBean.deleteMessages(10L,10L);
assertTrue(_queueMBean.getMessageCount() == (messageCount - 2));
assertTrue(_queueMBean.getReceivedMessageCount() == messageCount);
try
{
_queueMBean.viewMessageContent(10L);
fail("Message should no longer be on the queue");
}
catch(Exception e)
{
}
//delete remaining messages, leaving none
_queueMBean.deleteMessages(2L,9L);
assertTrue(_queueMBean.getMessageCount() == (0));
assertTrue(_queueMBean.getReceivedMessageCount() == messageCount);
//Ensure that the data has been removed from the Store
verifyBrokerState();
}
// todo: collect to a general testing class -duplicated from Systest/MessageReturntest
private void verifyBrokerState()
{
TestableMemoryMessageStore store = (TestableMemoryMessageStore) getVirtualHost().getMessageStore();
// Unlike MessageReturnTest there is no need for a delay as there this thread does the clean up.
assertEquals("Store should have no messages:" + store.getMessageCount(), 0, store.getMessageCount());
}
public void testConsumerCount() throws AMQException
{
assertTrue(getQueue().getActiveConsumerCount() == 0);
assertTrue(_queueMBean.getActiveConsumerCount() == 0);
InternalTestProtocolSession protocolSession = new InternalTestProtocolSession(getVirtualHost());
AMQChannel channel = new AMQChannel(protocolSession, 1, getMessageStore());
protocolSession.addChannel(channel);
Subscription subscription =
SUBSCRIPTION_FACTORY.createSubscription(channel.getChannelId(), protocolSession, new AMQShortString("test"), false, null, false, channel.getCreditManager());
getQueue().registerSubscription(subscription, false);
assertEquals(1,(int)_queueMBean.getActiveConsumerCount());
SubscriptionFactory subscriptionFactory = SUBSCRIPTION_FACTORY;
Subscription s1 = subscriptionFactory.createSubscription(channel.getChannelId(),
protocolSession,
new AMQShortString("S1"),
false,
null,
true,
channel.getCreditManager());
Subscription s2 = subscriptionFactory.createSubscription(channel.getChannelId(),
protocolSession,
new AMQShortString("S2"),
false,
null,
true,
channel.getCreditManager());
getQueue().registerSubscription(s1,false);
getQueue().registerSubscription(s2,false);
assertTrue(_queueMBean.getActiveConsumerCount() == 3);
assertTrue(_queueMBean.getConsumerCount() == 3);
s1.close();
assertEquals(2, (int) _queueMBean.getActiveConsumerCount());
assertTrue(_queueMBean.getConsumerCount() == 3);
}
public void testGeneralProperties() throws Exception
{
long maxQueueDepth = 1000; // in bytes
_queueMBean.setMaximumMessageCount(50000l);
_queueMBean.setMaximumMessageSize(2000l);
_queueMBean.setMaximumQueueDepth(maxQueueDepth);
assertEquals("Max MessageCount not set",50000,_queueMBean.getMaximumMessageCount().longValue());
assertEquals("Max MessageSize not set",2000, _queueMBean.getMaximumMessageSize().longValue());
assertEquals("Max QueueDepth not set",maxQueueDepth, _queueMBean.getMaximumQueueDepth().longValue());
assertEquals("Queue Name does not match", new AMQShortString(getName()), _queueMBean.getName());
assertFalse("AutoDelete should not be set.",_queueMBean.isAutoDelete());
assertFalse("Queue should not be durable.",_queueMBean.isDurable());
//set+get exclusivity using the mbean, and also verify it is actually updated in the queue
_queueMBean.setExclusive(true);
assertTrue("Exclusive property should be true.",_queueMBean.isExclusive());
assertTrue("Exclusive property should be true.", getQueue().isExclusive());
_queueMBean.setExclusive(false);
assertFalse("Exclusive property should be false.",_queueMBean.isExclusive());
assertFalse("Exclusive property should be false.", getQueue().isExclusive());
}
/**
* Tests view messages with two test messages. The first message is non-persistent, the second persistent
* and has timestamp/expiration.
*
*/
public void testViewMessages() throws Exception
{
sendMessages(1, false);
final Date msg2Timestamp = new Date();
final Date msg2Expiration = new Date(msg2Timestamp.getTime() + 1000);
sendMessages(1, true, msg2Timestamp.getTime(), msg2Expiration.getTime());
final TabularData tab = _queueMBean.viewMessages(1l, 2l);
assertEquals("Unexpected number of rows in table", 2, tab.size());
final Iterator<CompositeDataSupport> rowItr = (Iterator<CompositeDataSupport>) tab.values().iterator();
// Check row1
final CompositeDataSupport row1 = rowItr.next();
assertEquals("Message should have AMQ message id", 1l, row1.get(ManagedQueue.MSG_AMQ_ID));
assertNotNull("Expected message header array", row1.get(ManagedQueue.MSG_HEADER));
final Map<String, String> row1Headers = headerArrayToMap((String[])row1.get(ManagedQueue.MSG_HEADER));
assertEquals("Unexpected JMSPriority within header", "Non_Persistent", row1Headers.get("JMSDeliveryMode"));
assertEquals("Unexpected JMSTimestamp within header", "null", row1Headers.get("JMSTimestamp"));
assertEquals("Unexpected JMSExpiration within header", "null", row1Headers.get("JMSExpiration"));
final CompositeDataSupport row2 = rowItr.next();
assertEquals("Message should have AMQ message id", 2l, row2.get(ManagedQueue.MSG_AMQ_ID));
assertNotNull("Expected message header array", row2.get(ManagedQueue.MSG_HEADER));
final Map<String, String> row2Headers = headerArrayToMap((String[])row2.get(ManagedQueue.MSG_HEADER));
assertEquals("Unexpected JMSPriority within header", "Persistent", row2Headers.get("JMSDeliveryMode"));
assertEquals("Unexpected JMSTimestamp within header", FastDateFormat.getInstance(AMQQueueMBean.JMSTIMESTAMP_DATETIME_FORMAT).format(msg2Timestamp),
row2Headers.get("JMSTimestamp"));
assertEquals("Unexpected JMSExpiration within header", FastDateFormat.getInstance(AMQQueueMBean.JMSTIMESTAMP_DATETIME_FORMAT).format(msg2Expiration),
row2Headers.get("JMSExpiration"));
}
public void testViewMessageWithIllegalStartEndRanges() throws Exception
{
try
{
_queueMBean.viewMessages(0L, 3L);
fail();
}
catch (JMException ex)
{
// PASS
}
try
{
_queueMBean.viewMessages(2L, 1L);
fail();
}
catch (JMException ex)
{
// PASS
}
try
{
_queueMBean.viewMessages(-1L, 1L);
fail();
}
catch (JMException ex)
{
// PASS
}
try
{
long end = Integer.MAX_VALUE;
end+=2;
_queueMBean.viewMessages(1L, end);
fail("Expected Exception due to oversized(> 2^31) message range");
}
catch (JMException ex)
{
// PASS
}
}
public void testViewMessageContent() throws Exception
{
final List<AMQMessage> sentMessages = sendMessages(1, true);
final Long id = sentMessages.get(0).getMessageId();
final CompositeData messageData = _queueMBean.viewMessageContent(id);
assertNotNull(messageData);
}
public void testViewMessageContentWithUnknownMessageId() throws Exception
{
final List<AMQMessage> sentMessages = sendMessages(1, true);
final Long id = sentMessages.get(0).getMessageId();
try
{
_queueMBean.viewMessageContent(id + 1);
fail();
}
catch (JMException ex)
{
// PASS
}
}
public void testFlowControlProperties() throws Exception
{
assertTrue(_queueMBean.getCapacity() == 0);
assertTrue(_queueMBean.getFlowResumeCapacity() == 0);
assertFalse(_queueMBean.isFlowOverfull());
//capacity currently 0, try setting FlowResumeCapacity above this
try
{
_queueMBean.setFlowResumeCapacity(1L);
fail("Should have failed to allow setting FlowResumeCapacity above Capacity");
}
catch (IllegalArgumentException ex)
{
//expected exception
assertTrue(_queueMBean.getFlowResumeCapacity() == 0);
}
//add a message to the queue
sendMessages(1, true);
//(FlowResume)Capacity currently 0, set both to 2
_queueMBean.setCapacity(2L);
assertTrue(_queueMBean.getCapacity() == 2L);
_queueMBean.setFlowResumeCapacity(2L);
assertTrue(_queueMBean.getFlowResumeCapacity() == 2L);
//Try setting Capacity below FlowResumeCapacity
try
{
_queueMBean.setCapacity(1L);
fail("Should have failed to allow setting Capacity below FlowResumeCapacity");
}
catch (IllegalArgumentException ex)
{
//expected exception
assertTrue(_queueMBean.getCapacity() == 2);
}
//create a channel and use it to exercise the capacity check mechanism
AMQChannel channel = new AMQChannel(getSession(), 1, getMessageStore());
getQueue().checkCapacity(channel);
assertTrue(_queueMBean.isFlowOverfull());
assertTrue(channel.getBlocking());
//set FlowResumeCapacity to MESSAGE_SIZE and check queue is now underfull and channel unblocked
_queueMBean.setCapacity(MESSAGE_SIZE);//must increase capacity too
_queueMBean.setFlowResumeCapacity(MESSAGE_SIZE);
assertFalse(_queueMBean.isFlowOverfull());
assertFalse(channel.getBlocking());
}
public void testMaximumDeliveryCount() throws IOException
{
assertEquals("Unexpected default maximum delivery count", Integer.valueOf(0), _queueMBean.getMaximumDeliveryCount());
}
public void testViewAllMessages() throws Exception
{
final int messageCount = 5;
sendPersistentMessages(messageCount);
final TabularData messageTable = _queueMBean.viewMessages(1L, 5L);
assertNotNull("Message table should not be null", messageTable);
assertEquals("Unexpected number of rows", messageCount, messageTable.size());
final Iterator rowIterator = messageTable.values().iterator();
// Get its message ID
final CompositeDataSupport row1 = (CompositeDataSupport) rowIterator.next();
final Long msgId = (Long) row1.get("AMQ MessageId");
final Long queuePosition = (Long) row1.get("Queue Position");
final Integer deliveryCount = (Integer) row1.get("Delivery Count");
assertNotNull("Row should have value for queue position", queuePosition);
assertNotNull("Row should have value for msgid", msgId);
assertNotNull("Row should have value for deliveryCount", deliveryCount);
}
@Override
public void setUp() throws Exception
{
super.setUp();
_queueMBean = new AMQQueueMBean(getQueue());
}
public void tearDown()
{
ApplicationRegistry.remove();
}
private void sendPersistentMessages(int messageCount) throws AMQException
{
sendMessages(messageCount, true);
assertEquals("Expected " + messageCount + " messages in the queue", messageCount, _queueMBean
.getMessageCount().intValue());
}
private List<AMQMessage> sendMessages(int messageCount, boolean persistent) throws AMQException
{
return sendMessages(messageCount, persistent, 0l, 0l);
}
private List<AMQMessage> sendMessages(int messageCount, boolean persistent, long timestamp, long expiration) throws AMQException
{
final List<AMQMessage> sentMessages = new ArrayList<AMQMessage>();
for (int i = 0; i < messageCount; i++)
{
IncomingMessage currentMessage = createIncomingMessage(false, persistent, timestamp, expiration);
ArrayList<AMQQueue> qs = new ArrayList<AMQQueue>();
qs.add(getQueue());
currentMessage.enqueue(qs);
// route header
MessageMetaData mmd = currentMessage.headersReceived(System.currentTimeMillis());
// Add the message to the store so we have something to test later
currentMessage.setStoredMessage(getMessageStore().addMessage(mmd));
ContentChunk chunk = getSession().getMethodRegistry()
.getProtocolVersionMethodConverter()
.convertToContentChunk(
new ContentBody(new byte[(int) MESSAGE_SIZE]));
currentMessage.addContentBodyFrame(chunk);
currentMessage.getStoredMessage().addContent(0, ByteBuffer.wrap(chunk.getData()));
AMQMessage m = new AMQMessage(currentMessage.getStoredMessage());
for(BaseQueue q : currentMessage.getDestinationQueues())
{
q.enqueue(m);
}
sentMessages.add(m);
}
return sentMessages;
}
private IncomingMessage createIncomingMessage(final boolean immediate, boolean persistent, long timestamp, long expiration) throws AMQException
{
MessagePublishInfo publish = new MessagePublishInfo()
{
public AMQShortString getExchange()
{
return null;
}
public void setExchange(AMQShortString exchange)
{
}
public boolean isImmediate()
{
return immediate;
}
public boolean isMandatory()
{
return false;
}
public AMQShortString getRoutingKey()
{
return null;
}
};
ContentHeaderBody contentHeaderBody = new ContentHeaderBody();
contentHeaderBody.setBodySize(MESSAGE_SIZE); // in bytes
final BasicContentHeaderProperties props = new BasicContentHeaderProperties();
contentHeaderBody.setProperties(props);
props.setDeliveryMode((byte) (persistent ? 2 : 1));
if (timestamp > 0)
{
props.setTimestamp(timestamp);
}
if (expiration > 0)
{
props.setExpiration(expiration);
}
IncomingMessage msg = new IncomingMessage(publish);
msg.setContentHeaderBody(contentHeaderBody);
return msg;
}
/**
*
* Utility method to convert array of Strings in the form x = y into a
* map with key/value x => y.
*
*/
private Map<String,String> headerArrayToMap(final String[] headerArray)
{
final Map<String, String> headerMap = new HashMap<String, String>();
final List<String> headerList = Arrays.asList(headerArray);
for (Iterator<String> iterator = headerList.iterator(); iterator.hasNext();)
{
final String nameValuePair = iterator.next();
final String[] nameValue = nameValuePair.split(" *= *", 2);
headerMap.put(nameValue[0], nameValue[1]);
}
return headerMap;
}
}