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.usage.SystemUsage; 030 031 /** 032 * Adapter to the actual persistence mechanism used with ActiveMQ 033 * 034 * @version $Revision: 1.3 $ 035 */ 036 public interface PersistenceAdapter extends Service { 037 038 /** 039 * Returns a set of all the {@link org.apache.activemq.command.ActiveMQDestination} 040 * objects that the persistence store is aware exist. 041 * 042 * @return active destinations 043 */ 044 Set<ActiveMQDestination> getDestinations(); 045 046 /** 047 * Factory method to create a new queue message store with the given destination name 048 * @param destination 049 * @return the message store 050 * @throws IOException 051 */ 052 MessageStore createQueueMessageStore(ActiveMQQueue destination) throws IOException; 053 054 /** 055 * Factory method to create a new topic message store with the given destination name 056 * @param destination 057 * @return the topic message store 058 * @throws IOException 059 */ 060 TopicMessageStore createTopicMessageStore(ActiveMQTopic destination) throws IOException; 061 062 /** 063 * Cleanup method to remove any state associated with the given destination. 064 * This method does not stop the message store (it might not be cached). 065 * @param destination Destination to forget 066 */ 067 void removeQueueMessageStore(ActiveMQQueue destination); 068 069 /** 070 * Cleanup method to remove any state associated with the given destination 071 * This method does not stop the message store (it might not be cached). 072 * @param destination Destination to forget 073 */ 074 void removeTopicMessageStore(ActiveMQTopic destination); 075 076 /** 077 * Factory method to create a new persistent prepared transaction store for XA recovery 078 * @return transaction store 079 * @throws IOException 080 */ 081 TransactionStore createTransactionStore() throws IOException; 082 083 /** 084 * This method starts a transaction on the persistent storage - which is nothing to 085 * do with JMS or XA transactions - its purely a mechanism to perform multiple writes 086 * to a persistent store in 1 transaction as a performance optimization. 087 * <p/> 088 * Typically one transaction will require one disk synchronization point and so for 089 * real high performance its usually faster to perform many writes within the same 090 * transaction to minimize latency caused by disk synchronization. This is especially 091 * true when using tools like Berkeley Db or embedded JDBC servers. 092 * @param context 093 * @throws IOException 094 */ 095 void beginTransaction(ConnectionContext context) throws IOException; 096 097 098 /** 099 * Commit a persistence transaction 100 * @param context 101 * @throws IOException 102 * 103 * @see PersistenceAdapter#beginTransaction(ConnectionContext context) 104 */ 105 void commitTransaction(ConnectionContext context) throws IOException; 106 107 /** 108 * Rollback a persistence transaction 109 * @param context 110 * @throws IOException 111 * 112 * @see PersistenceAdapter#beginTransaction(ConnectionContext context) 113 */ 114 void rollbackTransaction(ConnectionContext context) throws IOException; 115 116 /** 117 * 118 * @return last broker sequence 119 * @throws IOException 120 */ 121 long getLastMessageBrokerSequenceId() throws IOException; 122 123 /** 124 * Delete's all the messages in the persistent store. 125 * 126 * @throws IOException 127 */ 128 void deleteAllMessages() throws IOException; 129 130 /** 131 * @param usageManager The UsageManager that is controlling the broker's memory usage. 132 */ 133 void setUsageManager(SystemUsage usageManager); 134 135 /** 136 * Set the name of the broker using the adapter 137 * @param brokerName 138 */ 139 void setBrokerName(String brokerName); 140 141 /** 142 * Set the directory where any data files should be created 143 * @param dir 144 */ 145 void setDirectory(File dir); 146 147 /** 148 * checkpoint any 149 * @param sync 150 * @throws IOException 151 * 152 */ 153 void checkpoint(boolean sync) throws IOException; 154 155 /** 156 * A hint to return the size of the store on disk 157 * @return disk space used in bytes of 0 if not implemented 158 */ 159 long size(); 160 }