diff options
Diffstat (limited to 'qpid/java/systests/src/main/java/org/apache/qpid/server/store')
| -rw-r--r-- | qpid/java/systests/src/main/java/org/apache/qpid/server/store/PersistentStoreTest.java | 193 | ||||
| -rw-r--r-- | qpid/java/systests/src/main/java/org/apache/qpid/server/store/SlowMessageStore.java | 321 |
2 files changed, 514 insertions, 0 deletions
diff --git a/qpid/java/systests/src/main/java/org/apache/qpid/server/store/PersistentStoreTest.java b/qpid/java/systests/src/main/java/org/apache/qpid/server/store/PersistentStoreTest.java new file mode 100644 index 0000000000..bf9d0e0f7b --- /dev/null +++ b/qpid/java/systests/src/main/java/org/apache/qpid/server/store/PersistentStoreTest.java @@ -0,0 +1,193 @@ +/* + * + * 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.store; + +import org.apache.qpid.client.AMQSession; +import org.apache.qpid.test.utils.QpidBrokerTestCase; + +import javax.jms.Connection; +import javax.jms.Destination; +import javax.jms.JMSException; +import javax.jms.Message; +import javax.jms.MessageConsumer; +import javax.jms.MessageProducer; +import javax.jms.Queue; +import javax.jms.Session; + +import java.util.ArrayList; +import java.util.List; + +public class PersistentStoreTest extends QpidBrokerTestCase +{ + + private static final int NUM_MESSAGES = 100; + private Connection _con; + private Session _session; + private Queue _destination; + private MessageConsumer _consumer; + + public void setUp() throws Exception, JMSException + { + super.setUp(); + _con = getConnection(); + _con.start(); + _session = _con.createSession(true, Session.SESSION_TRANSACTED); + _destination = _session.createQueue(getTestQueueName()); + _consumer = _session.createConsumer(_destination); + _consumer.close(); + + sendMessage(_session, _destination, NUM_MESSAGES); + _session.commit(); + } + + /** Checks that a new consumer on a new connection can get NUM_MESSAGES from _destination */ + private void checkMessages() throws Exception, JMSException + { + _con = getConnection(); + _session = _con.createSession(false, Session.AUTO_ACKNOWLEDGE); + _con.start(); + _consumer = _session.createConsumer(_destination); + for (int i = 1; i <= NUM_MESSAGES; i++) + { + Message msg = _consumer.receive(RECEIVE_TIMEOUT); + assertNotNull("Message " + i + " not received", msg); + assertEquals("Did not receive the expected message", i, msg.getIntProperty(INDEX)); + } + + Message msg = _consumer.receive(100); + if(msg != null) + { + fail("No more messages should be received, but received additional message with index: " + msg.getIntProperty(INDEX)); + } + } + +// /** +// * starts the server, sends 100 messages, restarts the server and gets 100 messages back +// * the test formerly referred to as BDB-Qpid-1 +// * @throws Exception +// */ +// public void testStartStop() throws Exception +// { +// restartBroker(); -- Not Currently a gracefull restart so not BDB-Qpid-1 +// checkMessages(); +// } + + /** + * starts the server, sends 100 messages, nukes then starts the server and gets 100 messages back + * the test formerly referred to as BDB-Qpid-2 + * + * @throws Exception + */ + public void testForcibleStartStop() throws Exception + { + restartBroker(); + checkMessages(); + } + +// /** +// * starts the server, sends 100 committed messages, 5 uncommited ones, +// * restarts the server and gets 100 messages back +// * the test formerly referred to as BDB-Qpid-5 +// * @throws Exception +// */ +// public void testStartStopMidTransaction() throws Exception +// { +// sendMessage(_session, _destination, 5); +// restartBroker(); -- Not Currently a gracefull restart so not BDB-Qpid-1 +// checkMessages(); +// } + + /** + * starts the server, sends 100 committed messages, 5 uncommited ones, + * nukes and starts the server and gets 100 messages back + * the test formerly referred to as BDB-Qpid-6 + * + * @throws Exception + */ + public void testForcibleStartStopMidTransaction() throws Exception + { + sendMessage(_session, _destination, 5); + //sync to ensure that the above messages have reached the broker + ((AMQSession) _session).sync(); + restartBroker(); + checkMessages(); + } + + /** + * starts the server, sends 100 committed messages, 5 uncommited ones, + * restarts the client and gets 100 messages back. + * the test formerly referred to as BDB-Qpid-7 + * + * FIXME: is this a PersistentStoreTest? Seems more like a transaction test to me.. aidan + * + * @throws Exception + */ + public void testClientDeathMidTransaction() throws Exception + { + sendMessage(_session, _destination, 5); + _con.close(); + checkMessages(); + } + +// /** +// * starts the server, sends 50 committed messages, copies $QPID_WORK to a new location, +// * sends 10 messages, stops the server, nukes the store, restores the copy, starts the server +// * checks that we get the first 50 back. +// */ +// public void testHotBackup() +// { +// -- removing as this will leave 100msgs on a queue +// } + + /** + * This test requires that we can send messages without commiting. + * QTC always commits the messages sent via sendMessages. + * + * @param session the session to use for sending + * @param destination where to send them to + * @param count no. of messages to send + * + * @return the sent messges + * + * @throws Exception + */ + @Override + public List<Message> sendMessage(Session session, Destination destination, + int count) throws Exception + { + List<Message> messages = new ArrayList<Message>(count); + + MessageProducer producer = session.createProducer(destination); + + for (int i = 1;i <= (count); i++) + { + Message next = createNextMessage(session, i); + + producer.send(next); + + messages.add(next); + } + + return messages; + } + +} diff --git a/qpid/java/systests/src/main/java/org/apache/qpid/server/store/SlowMessageStore.java b/qpid/java/systests/src/main/java/org/apache/qpid/server/store/SlowMessageStore.java new file mode 100644 index 0000000000..a5c38e7e33 --- /dev/null +++ b/qpid/java/systests/src/main/java/org/apache/qpid/server/store/SlowMessageStore.java @@ -0,0 +1,321 @@ +/* + * + * 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.store; + +import org.apache.commons.configuration.Configuration; +import org.apache.log4j.Logger; +import org.apache.qpid.AMQException; +import org.apache.qpid.AMQStoreException; +import org.apache.qpid.framing.AMQShortString; +import org.apache.qpid.framing.FieldTable; +import org.apache.qpid.server.exchange.Exchange; +import org.apache.qpid.server.queue.AMQQueue; +import org.apache.qpid.server.message.ServerMessage; +import org.apache.qpid.server.logging.LogSubject; + +import java.util.HashMap; +import java.util.Iterator; +import java.nio.ByteBuffer; + +public class SlowMessageStore implements MessageStore +{ + private static final Logger _logger = Logger.getLogger(SlowMessageStore.class); + private static final String DELAYS = "delays"; + private HashMap<String, Long> _preDelays = new HashMap<String, Long>(); + private HashMap<String, Long> _postDelays = new HashMap<String, Long>(); + private long _defaultDelay = 0L; + private MessageStore _realStore = new MemoryMessageStore(); + private static final String PRE = "pre"; + private static final String POST = "post"; + private String DEFAULT_DELAY = "default"; + + // ***** MessageStore Interface. + + public void configureConfigStore(String name, + ConfigurationRecoveryHandler recoveryHandler, + Configuration config, + LogSubject logSubject) throws Exception + { + //To change body of implemented methods use File | Settings | File Templates. + + _logger.info("Starting SlowMessageStore on Virtualhost:" + name); + Configuration delays = config.subset(DELAYS); + + configureDelays(delays); + + String messageStoreClass = config.getString("realStore"); + + if (delays.containsKey(DEFAULT_DELAY)) + { + _defaultDelay = delays.getLong(DEFAULT_DELAY); + } + + if (messageStoreClass != null) + { + Class clazz = Class.forName(messageStoreClass); + + Object o = clazz.newInstance(); + + if (!(o instanceof MessageStore)) + { + throw new ClassCastException("Message store class must implement " + MessageStore.class + ". Class " + clazz + + " does not."); + } + _realStore = (MessageStore) o; + _realStore.configureConfigStore(name, recoveryHandler, config, logSubject); + } + else + { + _realStore.configureConfigStore(name, recoveryHandler, config, logSubject); + } + } + + private void configureDelays(Configuration config) + { + Iterator delays = config.getKeys(); + + while (delays.hasNext()) + { + String key = (String) delays.next(); + if (key.endsWith(PRE)) + { + _preDelays.put(key.substring(0, key.length() - PRE.length() - 1), config.getLong(key)); + } + else if (key.endsWith(POST)) + { + _postDelays.put(key.substring(0, key.length() - POST.length() - 1), config.getLong(key)); + } + } + } + + private void doPostDelay(String method) + { + long delay = lookupDelay(_postDelays, method); + doDelay(delay); + } + + private void doPreDelay(String method) + { + long delay = lookupDelay(_preDelays, method); + doDelay(delay); + } + + private long lookupDelay(HashMap<String, Long> delays, String method) + { + Long delay = delays.get(method); + return (delay == null) ? _defaultDelay : delay; + } + + private void doDelay(long delay) + { + if (delay > 0) + { + long start = System.nanoTime(); + try + { + + Thread.sleep(delay); + } + catch (InterruptedException e) + { + _logger.warn("Interrupted : " + e); + } + + long slept = (System.nanoTime() - start) / 1000000; + + if (slept >= delay) + { + _logger.info("Done sleep for:" + slept+":"+delay); + } + else + { + _logger.info("Only sleep for:" + slept + " re-sleeping"); + doDelay(delay - slept); + } + } + } + + + public void configureMessageStore(String name, + MessageStoreRecoveryHandler recoveryHandler, + Configuration config, + LogSubject logSubject) throws Exception + { + _realStore.configureMessageStore(name, recoveryHandler, config, logSubject); + } + + public void close() throws Exception + { + doPreDelay("close"); + _realStore.close(); + doPostDelay("close"); + } + + public <M extends StorableMessageMetaData> StoredMessage<M> addMessage(M metaData) + { + return _realStore.addMessage(metaData); + } + + + public void createExchange(Exchange exchange) throws AMQStoreException + { + doPreDelay("createExchange"); + _realStore.createExchange(exchange); + doPostDelay("createExchange"); + } + + public void removeExchange(Exchange exchange) throws AMQStoreException + { + doPreDelay("removeExchange"); + _realStore.removeExchange(exchange); + doPostDelay("removeExchange"); + } + + public void bindQueue(Exchange exchange, AMQShortString routingKey, AMQQueue queue, FieldTable args) throws AMQStoreException + { + doPreDelay("bindQueue"); + _realStore.bindQueue(exchange, routingKey, queue, args); + doPostDelay("bindQueue"); + } + + public void unbindQueue(Exchange exchange, AMQShortString routingKey, AMQQueue queue, FieldTable args) throws AMQStoreException + { + doPreDelay("unbindQueue"); + _realStore.unbindQueue(exchange, routingKey, queue, args); + doPostDelay("unbindQueue"); + } + + public void createQueue(AMQQueue queue) throws AMQStoreException + { + createQueue(queue, null); + } + + public void createQueue(AMQQueue queue, FieldTable arguments) throws AMQStoreException + { + doPreDelay("createQueue"); + _realStore.createQueue(queue, arguments); + doPostDelay("createQueue"); + } + + public void removeQueue(AMQQueue queue) throws AMQStoreException + { + doPreDelay("removeQueue"); + _realStore.removeQueue(queue); + doPostDelay("removeQueue"); + } + + public void configureTransactionLog(String name, + TransactionLogRecoveryHandler recoveryHandler, + Configuration storeConfiguration, LogSubject logSubject) + throws Exception + { + _realStore.configureTransactionLog(name, recoveryHandler, storeConfiguration, logSubject); + } + + public Transaction newTransaction() + { + doPreDelay("beginTran"); + Transaction txn = new SlowTransaction(_realStore.newTransaction()); + doPostDelay("beginTran"); + return txn; + } + + + public boolean isPersistent() + { + return _realStore.isPersistent(); + } + + public void storeMessageHeader(Long messageNumber, ServerMessage message) + { + //To change body of implemented methods use File | Settings | File Templates. + } + + public void storeContent(Long messageNumber, long offset, ByteBuffer body) + { + //To change body of implemented methods use File | Settings | File Templates. + } + + public ServerMessage getMessage(Long messageNumber) + { + return null; //To change body of implemented methods use File | Settings | File Templates. + } + + private class SlowTransaction implements Transaction + { + private final Transaction _underlying; + + private SlowTransaction(Transaction underlying) + { + _underlying = underlying; + } + + public void enqueueMessage(TransactionLogResource queue, Long messageId) + throws AMQStoreException + { + doPreDelay("enqueueMessage"); + _underlying.enqueueMessage(queue, messageId); + doPostDelay("enqueueMessage"); + } + + public void dequeueMessage(TransactionLogResource queue, Long messageId) + throws AMQStoreException + { + doPreDelay("dequeueMessage"); + _underlying.dequeueMessage(queue, messageId); + doPostDelay("dequeueMessage"); + } + + public void commitTran() + throws AMQStoreException + { + doPreDelay("commitTran"); + _underlying.commitTran(); + doPostDelay("commitTran"); + } + + public StoreFuture commitTranAsync() + throws AMQStoreException + { + doPreDelay("commitTran"); + StoreFuture future = _underlying.commitTranAsync(); + doPostDelay("commitTran"); + return future; + } + + public void abortTran() + throws AMQStoreException + { + doPreDelay("abortTran"); + _underlying.abortTran(); + doPostDelay("abortTran"); + } + } + + public void updateQueue(AMQQueue queue) throws AMQStoreException + { + doPreDelay("updateQueue"); + _realStore.updateQueue(queue); + doPostDelay("updateQueue"); + } + + +} |