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.amq;
018    
019    import java.io.File;
020    
021    import org.apache.activemq.kaha.impl.async.AsyncDataManager;
022    import org.apache.activemq.kaha.impl.index.hash.HashIndex;
023    import org.apache.activemq.store.PersistenceAdapter;
024    import org.apache.activemq.store.PersistenceAdapterFactory;
025    import org.apache.activemq.store.ReferenceStoreAdapter;
026    import org.apache.activemq.thread.TaskRunnerFactory;
027    import org.apache.activemq.util.IOHelper;
028    
029    /**
030     * An implementation of {@link PersistenceAdapterFactory}
031     * 
032     * @org.apache.xbean.XBean element="amqPersistenceAdapterFactory"
033     * 
034     * @version $Revision: 1.17 $
035     */
036    public class AMQPersistenceAdapterFactory implements PersistenceAdapterFactory {
037        static final int DEFAULT_MAX_REFERNCE_FILE_LENGTH=2*1024*1024;
038        private TaskRunnerFactory taskRunnerFactory;
039        private File dataDirectory;
040        private int journalThreadPriority = Thread.MAX_PRIORITY;
041        private String brokerName = "localhost";
042        private ReferenceStoreAdapter referenceStoreAdapter;
043        private boolean syncOnWrite;
044        private boolean syncOnTransaction=true;
045        private boolean persistentIndex=true;
046        private boolean useNio = true;
047        private int maxFileLength = AsyncDataManager.DEFAULT_MAX_FILE_LENGTH;
048        private long cleanupInterval = AsyncDataManager.DEFAULT_CLEANUP_INTERVAL;
049        private int indexBinSize = HashIndex.DEFAULT_BIN_SIZE;
050        private int indexKeySize = HashIndex.DEFAULT_KEY_SIZE;
051        private int indexPageSize = HashIndex.DEFAULT_PAGE_SIZE;
052        private int indexMaxBinSize = HashIndex.MAXIMUM_CAPACITY;
053        private int indexLoadFactor = HashIndex.DEFAULT_LOAD_FACTOR;
054        private int maxReferenceFileLength=DEFAULT_MAX_REFERNCE_FILE_LENGTH;
055        private boolean recoverReferenceStore=true;
056        private boolean forceRecoverReferenceStore=false;
057        private long checkpointInterval = 1000 * 20;
058        private boolean useDedicatedTaskRunner;
059    
060    
061        /**
062         * @return a AMQPersistenceAdapter
063         * @see org.apache.activemq.store.PersistenceAdapterFactory#createPersistenceAdapter()
064         */
065        public PersistenceAdapter createPersistenceAdapter() {
066            AMQPersistenceAdapter result = new AMQPersistenceAdapter();
067            result.setDirectory(getDataDirectory());
068            result.setTaskRunnerFactory(getTaskRunnerFactory());
069            result.setBrokerName(getBrokerName());
070            result.setSyncOnWrite(isSyncOnWrite());
071            result.setPersistentIndex(isPersistentIndex());
072            result.setReferenceStoreAdapter(getReferenceStoreAdapter());
073            result.setUseNio(isUseNio());
074            result.setMaxFileLength(getMaxFileLength());
075            result.setCleanupInterval(getCleanupInterval());
076            result.setCheckpointInterval(getCheckpointInterval());
077            result.setIndexBinSize(getIndexBinSize());
078            result.setIndexKeySize(getIndexKeySize());
079            result.setIndexPageSize(getIndexPageSize());
080            result.setIndexMaxBinSize(getIndexMaxBinSize());
081            result.setIndexLoadFactor(getIndexLoadFactor());
082            result.setMaxReferenceFileLength(getMaxReferenceFileLength());
083            result.setForceRecoverReferenceStore(isForceRecoverReferenceStore());
084            result.setRecoverReferenceStore(isRecoverReferenceStore());
085            return result;
086        }
087    
088        public long getCleanupInterval() {
089            return cleanupInterval;
090        }
091        
092        public void setCleanupInterval(long val) {
093            cleanupInterval = val;
094        }
095    
096        /**
097         * @return the dataDirectory
098         */
099        public File getDataDirectory() {
100            if (this.dataDirectory == null) {
101                this.dataDirectory = new File(IOHelper.getDefaultDataDirectory(), IOHelper.toFileSystemSafeName(brokerName));
102            }
103            return this.dataDirectory;
104        }
105    
106        /**
107         * @param dataDirectory the dataDirectory to set
108         */
109        public void setDataDirectory(File dataDirectory) {
110            this.dataDirectory = dataDirectory;
111        }
112    
113        public boolean isUseDedicatedTaskRunner() {
114            return useDedicatedTaskRunner;
115        }
116        
117        public void setUseDedicatedTaskRunner(boolean useDedicatedTaskRunner) {
118            this.useDedicatedTaskRunner = useDedicatedTaskRunner;
119        }
120        
121        /**
122         * @return the taskRunnerFactory
123         */
124        public TaskRunnerFactory getTaskRunnerFactory() {
125            if (taskRunnerFactory == null) {
126                taskRunnerFactory = new TaskRunnerFactory("AMQPersistenceAdaptor Task", journalThreadPriority,
127                                                          true, 1000, isUseDedicatedTaskRunner());
128            }
129            return taskRunnerFactory;
130        }
131    
132        /**
133         * @param taskRunnerFactory the taskRunnerFactory to set
134         */
135        public void setTaskRunnerFactory(TaskRunnerFactory taskRunnerFactory) {
136            this.taskRunnerFactory = taskRunnerFactory;
137        }
138    
139        /**
140         * @return the journalThreadPriority
141         */
142        public int getJournalThreadPriority() {
143            return this.journalThreadPriority;
144        }
145    
146        /**
147         * @param journalThreadPriority the journalThreadPriority to set
148         */
149        public void setJournalThreadPriority(int journalThreadPriority) {
150            this.journalThreadPriority = journalThreadPriority;
151        }
152    
153        /**
154         * @return the brokerName
155         */
156        public String getBrokerName() {
157            return this.brokerName;
158        }
159    
160        /**
161         * @param brokerName the brokerName to set
162         */
163        public void setBrokerName(String brokerName) {
164            this.brokerName = brokerName;
165        }
166    
167        /**
168         * @return the referenceStoreAdapter
169         */
170        public ReferenceStoreAdapter getReferenceStoreAdapter() {
171            return this.referenceStoreAdapter;
172        }
173    
174        /**
175         * @param referenceStoreAdapter the referenceStoreAdapter to set
176         */
177        public void setReferenceStoreAdapter(ReferenceStoreAdapter referenceStoreAdapter) {
178            this.referenceStoreAdapter = referenceStoreAdapter;
179        }
180        
181        public boolean isPersistentIndex() {
182                    return persistentIndex;
183            }
184    
185            public void setPersistentIndex(boolean persistentIndex) {
186                    this.persistentIndex = persistentIndex;
187            }
188    
189            public boolean isSyncOnWrite() {
190                    return syncOnWrite;
191            }
192    
193            public void setSyncOnWrite(boolean syncOnWrite) {
194                    this.syncOnWrite = syncOnWrite;
195            }
196            
197            public boolean isSyncOnTransaction() {
198            return syncOnTransaction;
199        }
200    
201        public void setSyncOnTransaction(boolean syncOnTransaction) {
202            this.syncOnTransaction = syncOnTransaction;
203        }
204    
205            public boolean isUseNio() {
206                    return useNio;
207            }
208    
209            public void setUseNio(boolean useNio) {
210                    this.useNio = useNio;
211            }
212    
213            public int getMaxFileLength() {
214                    return maxFileLength;
215            }
216    
217            public void setMaxFileLength(int maxFileLength) {
218                    this.maxFileLength = maxFileLength;
219            }
220    
221        /**
222         * @return the indexBinSize
223         */
224        public int getIndexBinSize() {
225            return indexBinSize;
226        }
227    
228        /**
229         * @param indexBinSize the indexBinSize to set
230         */
231        public void setIndexBinSize(int indexBinSize) {
232            this.indexBinSize = indexBinSize;
233        }
234    
235        /**
236         * @return the indexKeySize
237         */
238        public int getIndexKeySize() {
239            return indexKeySize;
240        }
241    
242        /**
243         * @param indexKeySize the indexKeySize to set
244         */
245        public void setIndexKeySize(int indexKeySize) {
246            this.indexKeySize = indexKeySize;
247        }
248    
249        /**
250         * @return the indexPageSize
251         */
252        public int getIndexPageSize() {
253            return indexPageSize;
254        }
255    
256        /**
257         * @param indexPageSize the indexPageSize to set
258         */
259        public void setIndexPageSize(int indexPageSize) {
260            this.indexPageSize = indexPageSize;
261        }
262    
263        /**
264         * @return the indexMaxBinSize
265         */
266        public int getIndexMaxBinSize() {
267            return indexMaxBinSize;
268        }
269    
270        /**
271         * @param indexMaxBinSize the indexMaxBinSize to set
272         */
273        public void setIndexMaxBinSize(int indexMaxBinSize) {
274            this.indexMaxBinSize = indexMaxBinSize;
275        }
276    
277        /**
278         * @return the indexLoadFactor
279         */
280        public int getIndexLoadFactor() {
281            return indexLoadFactor;
282        }
283    
284        /**
285         * @param indexLoadFactor the indexLoadFactor to set
286         */
287        public void setIndexLoadFactor(int indexLoadFactor) {
288            this.indexLoadFactor = indexLoadFactor;
289        }
290    
291        /**
292         * @return the maxReferenceFileLength
293         */
294        public int getMaxReferenceFileLength() {
295            return maxReferenceFileLength;
296        }
297    
298        /**
299         * @param maxReferenceFileLength the maxReferenceFileLength to set
300         */
301        public void setMaxReferenceFileLength(int maxReferenceFileLength) {
302            this.maxReferenceFileLength = maxReferenceFileLength;
303        }
304    
305        /**
306         * @return the recoverReferenceStore
307         */
308        public boolean isRecoverReferenceStore() {
309            return recoverReferenceStore;
310        }
311    
312        /**
313         * @param recoverReferenceStore the recoverReferenceStore to set
314         */
315        public void setRecoverReferenceStore(boolean recoverReferenceStore) {
316            this.recoverReferenceStore = recoverReferenceStore;
317        }
318    
319        /**
320         * @return the forceRecoverReferenceStore
321         */
322        public boolean isForceRecoverReferenceStore() {
323            return forceRecoverReferenceStore;
324        }
325    
326        /**
327         * @param forceRecoverReferenceStore the forceRecoverReferenceStore to set
328         */
329        public void setForceRecoverReferenceStore(boolean forceRecoverReferenceStore) {
330            this.forceRecoverReferenceStore = forceRecoverReferenceStore;
331        }
332    
333        /**
334         * @return the checkpointInterval
335         */
336        public long getCheckpointInterval() {
337            return checkpointInterval;
338        }
339    
340        /**
341         * @param checkpointInterval the checkpointInterval to set
342         */
343        public void setCheckpointInterval(long checkpointInterval) {
344            this.checkpointInterval = checkpointInterval;
345        }
346    }