001 /**
002 * Licensed to the Apache Software Foundation (ASF) under one or more
003 * contributor license agreements. See the NOTICE file distributed with
004 * this work for additional information regarding copyright ownership.
005 * The ASF licenses this file to You under the Apache License, Version 2.0
006 * (the "License"); you may not use this file except in compliance with
007 * the License. You may obtain a copy of the License at
008 *
009 * http://www.apache.org/licenses/LICENSE-2.0
010 *
011 * Unless required by applicable law or agreed to in writing, software
012 * distributed under the License is distributed on an "AS IS" BASIS,
013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 * See the License for the specific language governing permissions and
015 * limitations under the License.
016 */
017 package org.apache.activemq.store;
018
019 import java.io.File;
020 import java.io.IOException;
021 import java.util.Set;
022
023 import org.apache.activemq.Service;
024 import org.apache.activemq.broker.ConnectionContext;
025 import org.apache.activemq.broker.region.Destination;
026 import org.apache.activemq.command.ActiveMQDestination;
027 import org.apache.activemq.command.ActiveMQQueue;
028 import org.apache.activemq.command.ActiveMQTopic;
029 import org.apache.activemq.command.ProducerId;
030 import org.apache.activemq.usage.SystemUsage;
031
032 /**
033 * Adapter to the actual persistence mechanism used with ActiveMQ
034 *
035 *
036 */
037 public interface PersistenceAdapter extends Service {
038
039 /**
040 * Returns a set of all the {@link org.apache.activemq.command.ActiveMQDestination}
041 * objects that the persistence store is aware exist.
042 *
043 * @return active destinations
044 */
045 Set<ActiveMQDestination> getDestinations();
046
047 /**
048 * Factory method to create a new queue message store with the given destination name
049 * @param destination
050 * @return the message store
051 * @throws IOException
052 */
053 MessageStore createQueueMessageStore(ActiveMQQueue destination) throws IOException;
054
055 /**
056 * Factory method to create a new topic message store with the given destination name
057 * @param destination
058 * @return the topic message store
059 * @throws IOException
060 */
061 TopicMessageStore createTopicMessageStore(ActiveMQTopic destination) throws IOException;
062
063 /**
064 * Cleanup method to remove any state associated with the given destination.
065 * This method does not stop the message store (it might not be cached).
066 * @param destination Destination to forget
067 */
068 void removeQueueMessageStore(ActiveMQQueue destination);
069
070 /**
071 * Cleanup method to remove any state associated with the given destination
072 * This method does not stop the message store (it might not be cached).
073 * @param destination Destination to forget
074 */
075 void removeTopicMessageStore(ActiveMQTopic destination);
076
077 /**
078 * Factory method to create a new persistent prepared transaction store for XA recovery
079 * @return transaction store
080 * @throws IOException
081 */
082 TransactionStore createTransactionStore() throws IOException;
083
084 /**
085 * This method starts a transaction on the persistent storage - which is nothing to
086 * do with JMS or XA transactions - its purely a mechanism to perform multiple writes
087 * to a persistent store in 1 transaction as a performance optimization.
088 * <p/>
089 * Typically one transaction will require one disk synchronization point and so for
090 * real high performance its usually faster to perform many writes within the same
091 * transaction to minimize latency caused by disk synchronization. This is especially
092 * true when using tools like Berkeley Db or embedded JDBC servers.
093 * @param context
094 * @throws IOException
095 */
096 void beginTransaction(ConnectionContext context) throws IOException;
097
098
099 /**
100 * Commit a persistence transaction
101 * @param context
102 * @throws IOException
103 *
104 * @see PersistenceAdapter#beginTransaction(ConnectionContext context)
105 */
106 void commitTransaction(ConnectionContext context) throws IOException;
107
108 /**
109 * Rollback a persistence transaction
110 * @param context
111 * @throws IOException
112 *
113 * @see PersistenceAdapter#beginTransaction(ConnectionContext context)
114 */
115 void rollbackTransaction(ConnectionContext context) throws IOException;
116
117 /**
118 *
119 * @return last broker sequence
120 * @throws IOException
121 */
122 long getLastMessageBrokerSequenceId() throws IOException;
123
124 /**
125 * Delete's all the messages in the persistent store.
126 *
127 * @throws IOException
128 */
129 void deleteAllMessages() throws IOException;
130
131 /**
132 * @param usageManager The UsageManager that is controlling the broker's memory usage.
133 */
134 void setUsageManager(SystemUsage usageManager);
135
136 /**
137 * Set the name of the broker using the adapter
138 * @param brokerName
139 */
140 void setBrokerName(String brokerName);
141
142 /**
143 * Set the directory where any data files should be created
144 * @param dir
145 */
146 void setDirectory(File dir);
147
148 /**
149 * checkpoint any
150 * @param sync
151 * @throws IOException
152 *
153 */
154 void checkpoint(boolean sync) throws IOException;
155
156 /**
157 * A hint to return the size of the store on disk
158 * @return disk space used in bytes of 0 if not implemented
159 */
160 long size();
161
162 /**
163 * return the last stored producer sequenceId for this producer Id
164 * used to suppress duplicate sends on failover reconnect at the transport
165 * when a reconnect occurs
166 * @param id the producerId to find a sequenceId for
167 * @return the last stored sequence id or -1 if no suppression needed
168 */
169 long getLastProducerSequenceId(ProducerId id) throws IOException;
170 }