java.lang.Object
- org.apache.activemq.artemis.core.journal.impl.JournalImpl

All Implemented Interfaces:

JournalRecordProvider, Journal, TestableJournal, ActiveMQComponent
```
public class JournalImpl
extends Object
implements TestableJournal, JournalRecordProvider
```
A circular log implementation.

Look at load(LoaderCallback) for the file layout

Nested Class Summary
- Nested classes/interfaces inherited from interface org.apache.activemq.artemis.core.journal.Journal
  Journal.JournalState

Field Summary

Fields
Modifier and Type	Field	Description
`static byte`	`ADD_RECORD`
`static byte`	`ADD_RECORD_TX`
`static String`	`BKP`
`static byte`	`COMMIT_RECORD`
`static byte`	`DELETE_RECORD`
`static byte`	`DELETE_RECORD_TX`
`static byte`	`EVENT_RECORD`
`protected int`	`fileSize`
`protected static byte`	`FILL_CHARACTER`
`static int`	`FORMAT_VERSION`
`protected ExecutorFactory`	`ioExecutorFactory`
`static int`	`MIN_FILE_SIZE`
`static byte`	`PREPARE_RECORD`
`protected boolean`	`removeExtraFilesOnLoad`
`static byte`	`ROLLBACK_RECORD`
`static int`	`SIZE_ADD_RECORD`
`static int`	`SIZE_ADD_RECORD_TX`
`static int`	`SIZE_COMMIT_RECORD`
`static int`	`SIZE_COMPLETE_TRANSACTION_RECORD`
`static int`	`SIZE_DELETE_RECORD`
`static int`	`SIZE_DELETE_RECORD_TX`
`static int`	`SIZE_HEADER`
`static int`	`SIZE_PREPARE_RECORD`
`static int`	`SIZE_ROLLBACK_RECORD`
`static double`	`UPDATE_FACTOR`	this is a factor where when you have more than UPDATE_FACTOR updates for every ADD.
`static byte`	`UPDATE_RECORD`
`static byte`	`UPDATE_RECORD_TX`

Constructor Summary

Constructors
Constructor	Description
`JournalImpl(int fileSize, int minFiles, int poolSize, int compactMinFiles, int compactPercentage, int journalFileOpenTimeout, SequentialFileFactory fileFactory, String filePrefix, String fileExtension, int maxAIO, int userVersion)`
`JournalImpl(int fileSize, int minFiles, int poolSize, int compactMinFiles, int compactPercentage, SequentialFileFactory fileFactory, String filePrefix, String fileExtension, int maxAIO)`
`JournalImpl(int fileSize, int minFiles, int poolSize, int compactMinFiles, int compactPercentage, SequentialFileFactory fileFactory, String filePrefix, String fileExtension, int maxAIO, int userVersion)`
`JournalImpl(ExecutorFactory ioExecutors, int fileSize, int minFiles, int poolSize, int compactMinFiles, int compactPercentage, int journalFileOpenTimeout, SequentialFileFactory fileFactory, String filePrefix, String fileExtension, int maxAIO, int userVersion)`
`JournalImpl(ExecutorFactory ioExecutors, int fileSize, int minFiles, int poolSize, int compactMinFiles, int compactPercentage, int journalFileOpenTimeout, SequentialFileFactory fileFactory, String filePrefix, String fileExtension, int maxAIO, int userVersion, IOCriticalErrorListener criticalErrorListener, int maxAtticFiles)`
`JournalImpl(ExecutorFactory ioExecutors, int fileSize, int minFiles, int poolSize, int compactMinFiles, int compactPercentage, SequentialFileFactory fileFactory, String filePrefix, String fileExtension, int maxAIO, int userVersion)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`void`	`appendAddEvent(long id, byte recordType, Persister persister, Object record, boolean sync, IOCompletion callback)`	An event is data recorded on the journal, but it won't have any weight or deletes.
`void`	`appendAddRecord(long id, byte recordType, byte[] record, boolean sync)`
`void`	`appendAddRecord(long id, byte recordType, Persister persister, Object record, boolean sync)`
`void`	`appendAddRecord(long id, byte recordType, Persister persister, Object record, boolean sync, IOCompletion callback)`
`void`	`appendAddRecordTransactional(long txID, long id, byte recordType, byte[] record)`
`void`	`appendAddRecordTransactional(long txID, long id, byte recordType, Persister persister, Object record)`
`void`	`appendCommitRecord(long txID, boolean sync)`
`void`	`appendCommitRecord(long txID, boolean sync, IOCompletion callback)`
`void`	`appendCommitRecord(long txID, boolean sync, IOCompletion callback, boolean lineUpContext)`	Regarding the number of operations in a given file see `JournalCompleteRecordTX`.
`void`	`appendDeleteRecord(long id, boolean sync)`
`void`	`appendDeleteRecord(long id, boolean sync, IOCompletion callback)`
`void`	`appendDeleteRecordTransactional(long txID, long id)`
`void`	`appendDeleteRecordTransactional(long txID, long id, byte[] record)`
`void`	`appendDeleteRecordTransactional(long txID, long id, EncodingSupport record)`
`void`	`appendPrepareRecord(long txID, byte[] transactionData, boolean sync)`
`void`	`appendPrepareRecord(long txID, EncodingSupport transactionData, boolean sync)`	If the system crashed after a prepare was called, it should store information that is required to bring the transaction back to a state it could be committed.
`void`	`appendPrepareRecord(long txID, EncodingSupport transactionData, boolean sync, IOCompletion callback)`	If the system crashed after a prepare was called, it should store information that is required to bring the transaction back to a state it could be committed.
`void`	`appendRollbackRecord(long txID, boolean sync)`
`void`	`appendRollbackRecord(long txID, boolean sync, IOCompletion callback)`
`void`	`appendUpdateRecord(long id, byte recordType, byte[] record, boolean sync)`
`void`	`appendUpdateRecord(long id, byte recordType, Persister persister, Object record, boolean sync)`
`void`	`appendUpdateRecord(long id, byte recordType, Persister persister, Object record, boolean sync, IOCompletion callback)`
`void`	`appendUpdateRecordTransactional(long txID, long id, byte recordType, byte[] record)`
`void`	`appendUpdateRecordTransactional(long txID, long id, byte recordType, Persister persister, Object record)`
`boolean`	`checkReclaimStatus()`	This method is called automatically when a new file is opened.
`void`	`compact()`	Note: This method can't be called from the main executor, as it will invoke other methods depending on it.
`protected SequentialFile`	`createControlFile(List<JournalFile> files, List<JournalFile> newFiles, Pair<String,String> cleanupRename)`
`Map<Long,JournalFile>`	`createFilesForBackupSync(long[] fileIds)`	Returns Map with a `JournalFile` for all existing files.
`String`	`debug()`
`void`	`debugWait()`	Method for use on testcases.
`protected void`	`deleteControlFile(SequentialFile controlFile)`
`void`	`flush()`	It will make sure there are no more pending operations on the Executors.
`boolean`	`flushAppendExecutor(long timeout, TimeUnit unit)`
`void`	`forceBackup(int timeout, TimeUnit unit)`
`void`	`forceMoveNextFile()`	Force the usage of a new `JournalFile`.
`int`	`getAlignment()`
`int`	`getCompactCount()`	For tests only
`int`	`getCompactMinFiles()`
`JournalCompactor`	`getCompactor()`
`float`	`getCompactPercentage()`
`IOCriticalErrorListener`	`getCriticalErrorListener()`
`JournalFile`	`getCurrentFile()`
`JournalFile[]`	`getDataFiles()`	Returns the `JournalFile`s in use.
`int`	`getDataFilesCount()`
`String`	`getDatePortion(String name)`
`long`	`getDatePortionMillis(String name)`
`String`	`getFileExtension()`
`SequentialFileFactory`	`getFileFactory()`
`String`	`getFilePrefix()`
`int`	`getFileSize()`
`JournalFilesRepository`	`getFilesRepository()`
`int`	`getFreeFilesCount()`
`String`	`getHistoryFileName(long sequence, Calendar calendar)`
`int`	`getIDMapSize()`
`int`	`getMaxAIO()`
`long`	`getMaxRecordSize()`	The max size record that can be stored in the journal
`int`	`getMinFiles()`
`int`	`getNumberOfRecords()`
`int`	`getOpenedFilesCount()`
`ConcurrentLongHashMap<JournalRecord>`	`getRecords()`
`protected SyncIOCompletion`	`getSyncCallback(boolean sync)`
`int`	`getUserVersion()`
`static int`	`initFileHeader(SequentialFileFactory fileFactory, SequentialFile sequentialFile, int userVersion, long fileID)`
`boolean`	`isAutoReclaim()`
`boolean`	`isHistory()`
`boolean`	`isRemoveExtraFilesOnLoad()`
`boolean`	`isStarted()`
`void`	`lineUpContext(IOCompletion callback)`
`JournalLoadInformation`	`load(List<RecordInfo> committedRecords, List<PreparedTransactionInfo> preparedTransactions, TransactionFailureCallback transactionFailure, boolean fixBadTx)`
`JournalLoadInformation`	`load(LoaderCallback loadManager)`	Load data accordingly to the record layouts
`JournalLoadInformation`	`load(SparseArrayLinkedList<RecordInfo> committedRecords, List<PreparedTransactionInfo> preparedTransactions, TransactionFailureCallback failureCallback, boolean fixBadTX)`
`JournalLoadInformation`	`loadInternalOnly()`	Load internal data structures and not expose any data.
`JournalLoadInformation`	`loadSyncOnly(Journal.JournalState syncState)`	Load internal data structures, and remain waiting for synchronization to complete.
`protected void`	`moveNextFile(boolean scheduleReclaim, boolean blockOnClose)`	You need to guarantee lock.acquire() before calling this method!
`protected void`	`onCompactDone()`	This is an interception point for testcases, when the compacted files are written, before replacing the data structures
`protected void`	`onCompactLockingTheJournal()`	This is an interception point for testcases, when the compacted files are written, to be called as soon as the compactor gets a writeLock
`protected void`	`onCompactStart()`	This is an interception point for testcases, when the compacted files are written, before replacing the data structures
`List<JournalFile>`	`orderFiles()`	this method is used internally only however tools may use it to maintenance.
`void`	`processBackup()`	With the exception of initialization, this has to be always called within the compactorExecutor
`void`	`processBackupCleanup()`	It will check max files and max days on files and remove extra files.
`JournalFileImpl`	`readFileHeader(SequentialFile file)`
`static int`	`readJournalFile(SequentialFileFactory fileFactory, JournalFile file, JournalReaderCallback reader)`	this method is used internally only however tools may use it to maintenance.
`static int`	`readJournalFile(SequentialFileFactory fileFactory, JournalFile file, JournalReaderCallback reader, AtomicReference<ByteBuffer> wholeFileBufferReference)`
`static int`	`readJournalFile(SequentialFileFactory fileFactory, JournalFile file, JournalReaderCallback reader, AtomicReference<ByteBuffer> wholeFileBufferReference, boolean reclaimed)`
`static int`	`readJournalFile(SequentialFileFactory fileFactory, JournalFile file, JournalReaderCallback reader, AtomicReference<ByteBuffer> wholeFileBufferReference, boolean reclaimed, io.netty.util.collection.ByteObjectHashMap<Boolean> replaceableRecords)`
`String`	`removeBackupExtension(String name)`
`protected static String`	`renameExtensionFile(String name, String extension)`
`protected void`	`renameFiles(List<JournalFile> oldFiles, List<JournalFile> newFiles)`	being protected as testcases can override this method
`void`	`replaceableRecord(byte recordType)`	This will declare a record type as being replaceable on updates.
`void`	`replicationSyncFinished()`	Restarts file reclaim and compacting on the journal.
`void`	`replicationSyncPreserveOldFiles()`	Stops any operation that may delete or modify old (stale) data.
`void`	`scheduleCompactAndBlock(int timeout)`	This method will start compact using the compactorExecutor and block up to timeout seconds
`void`	`setAutoReclaim(boolean autoReclaim)`
`JournalImpl`	`setCriticalErrorListener(IOCriticalErrorListener criticalErrorListener)`
`JournalImpl`	`setHistoryFolder(File historyFolder, long maxBytes, long period)`
`void`	`setRemoveExtraFilesOnLoad(boolean setting)`
`protected JournalFile`	`setUpCurrentFile(int lastDataPos)`
`void`	`start()`
`void`	`stop()`
`protected JournalFile`	`switchFileIfNecessary(int size)`
`void`	`synchronizationLock()`	Write lock the Journal and write lock the compacting process.
`void`	`synchronizationUnlock()`	Unlock the Journal and the compacting process.
`void`	`testCompact()`
`String`	`toString()`
`void`	`tryAppendDeleteRecord(long id, boolean sync, JournalUpdateCallback updateCallback, IOCompletion callback)`
`void`	`tryAppendDeleteRecord(long id, JournalUpdateCallback updateCallback, boolean sync)`
`void`	`tryAppendUpdateRecord(long id, byte recordType, byte[] record, JournalUpdateCallback updateCallback, boolean sync, boolean replaceableRecord)`
`void`	`tryAppendUpdateRecord(long id, byte recordType, Persister persister, Object record, boolean sync, boolean replaceableUpdate, JournalUpdateCallback updateCallback, IOCompletion callback)`
`void`	`tryAppendUpdateRecord(long id, byte recordType, Persister persister, Object record, JournalUpdateCallback updateCallback, boolean sync, boolean replaceableUpdate)`
`protected SequentialFile`	`writeControlFile(SequentialFileFactory fileFactory, List<JournalFile> files, List<JournalFile> newFiles, List<Pair<String,String>> renames)`
`static void`	`writeHeader(ActiveMQBuffer buffer, int userVersion, long fileID)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.apache.activemq.artemis.core.server.ActiveMQComponent
asyncStop

Field Detail
- UPDATE_FACTOR
```
public static final double UPDATE_FACTOR
```
  this is a factor where when you have more than UPDATE_FACTOR updates for every ADD. When this happens we should issue a compacting event. I don't foresee users needing to configure this value. However if this ever happens we would have a system property aligned for this. With that being said, if you needed this, please raise an issue on why you needed to use this, so we may eventually add it to broker.xml when a real use case would determine the configuration exposed in there. To update this value, define a System Property org.apache.activemq.artemis.core.journal.impl.JournalImpl.UPDATE_FACTOR=YOUR VALUE We only calculate this against replaceable updates, on this case for redelivery counts and rescheduled redelivery in artemis server
- BKP
```
public static final String BKP
```
  See Also:
  
  Constant Field Values
- FORMAT_VERSION
```
public static final int FORMAT_VERSION
```
  See Also:
  
  Constant Field Values
- MIN_FILE_SIZE
```
public static final int MIN_FILE_SIZE
```
  See Also:
  
  Constant Field Values
- SIZE_HEADER
```
public static final int SIZE_HEADER
```
  See Also:
  
  Constant Field Values
- SIZE_ADD_RECORD
```
public static final int SIZE_ADD_RECORD
```
  See Also:
  
  Constant Field Values
- EVENT_RECORD
```
public static final byte EVENT_RECORD
```
  See Also:
  
  Constant Field Values
- ADD_RECORD
```
public static final byte ADD_RECORD
```
  See Also:
  
  Constant Field Values
- UPDATE_RECORD
```
public static final byte UPDATE_RECORD
```
  See Also:
  
  Constant Field Values
- SIZE_ADD_RECORD_TX
```
public static final int SIZE_ADD_RECORD_TX
```
  See Also:
  
  Constant Field Values
- ADD_RECORD_TX
```
public static final byte ADD_RECORD_TX
```
  See Also:
  
  Constant Field Values
- UPDATE_RECORD_TX
```
public static final byte UPDATE_RECORD_TX
```
  See Also:
  
  Constant Field Values
- SIZE_DELETE_RECORD_TX
```
public static final int SIZE_DELETE_RECORD_TX
```
  See Also:
  
  Constant Field Values
- DELETE_RECORD_TX
```
public static final byte DELETE_RECORD_TX
```
  See Also:
  
  Constant Field Values
- SIZE_DELETE_RECORD
```
public static final int SIZE_DELETE_RECORD
```
  See Also:
  
  Constant Field Values
- DELETE_RECORD
```
public static final byte DELETE_RECORD
```
  See Also:
  
  Constant Field Values
- SIZE_COMPLETE_TRANSACTION_RECORD
```
public static final int SIZE_COMPLETE_TRANSACTION_RECORD
```
  See Also:
  
  Constant Field Values
- SIZE_PREPARE_RECORD
```
public static final int SIZE_PREPARE_RECORD
```
  See Also:
  
  Constant Field Values
- PREPARE_RECORD
```
public static final byte PREPARE_RECORD
```
  See Also:
  
  Constant Field Values
- SIZE_COMMIT_RECORD
```
public static final int SIZE_COMMIT_RECORD
```
  See Also:
  
  Constant Field Values
- COMMIT_RECORD
```
public static final byte COMMIT_RECORD
```
  See Also:
  
  Constant Field Values
- SIZE_ROLLBACK_RECORD
```
public static final int SIZE_ROLLBACK_RECORD
```
  See Also:
  
  Constant Field Values
- ROLLBACK_RECORD
```
public static final byte ROLLBACK_RECORD
```
  See Also:
  
  Constant Field Values
- FILL_CHARACTER
```
protected static final byte FILL_CHARACTER
```
  See Also:
  
  Constant Field Values
- ioExecutorFactory
```
protected ExecutorFactory ioExecutorFactory
```
- fileSize
```
protected final int fileSize
```
- removeExtraFilesOnLoad
```
protected boolean removeExtraFilesOnLoad
```

Constructor Detail

JournalImpl

public JournalImpl(int fileSize,
                   int minFiles,
                   int poolSize,
                   int compactMinFiles,
                   int compactPercentage,
                   SequentialFileFactory fileFactory,
                   String filePrefix,
                   String fileExtension,
                   int maxAIO)

JournalImpl

public JournalImpl(int fileSize,
                   int minFiles,
                   int poolSize,
                   int compactMinFiles,
                   int compactPercentage,
                   SequentialFileFactory fileFactory,
                   String filePrefix,
                   String fileExtension,
                   int maxAIO,
                   int userVersion)

JournalImpl

public JournalImpl(int fileSize,
                   int minFiles,
                   int poolSize,
                   int compactMinFiles,
                   int compactPercentage,
                   int journalFileOpenTimeout,
                   SequentialFileFactory fileFactory,
                   String filePrefix,
                   String fileExtension,
                   int maxAIO,
                   int userVersion)

JournalImpl

public JournalImpl(ExecutorFactory ioExecutors,
                   int fileSize,
                   int minFiles,
                   int poolSize,
                   int compactMinFiles,
                   int compactPercentage,
                   SequentialFileFactory fileFactory,
                   String filePrefix,
                   String fileExtension,
                   int maxAIO,
                   int userVersion)

JournalImpl

public JournalImpl(ExecutorFactory ioExecutors,
                   int fileSize,
                   int minFiles,
                   int poolSize,
                   int compactMinFiles,
                   int compactPercentage,
                   int journalFileOpenTimeout,
                   SequentialFileFactory fileFactory,
                   String filePrefix,
                   String fileExtension,
                   int maxAIO,
                   int userVersion)

JournalImpl

public JournalImpl(ExecutorFactory ioExecutors,
                   int fileSize,
                   int minFiles,
                   int poolSize,
                   int compactMinFiles,
                   int compactPercentage,
                   int journalFileOpenTimeout,
                   SequentialFileFactory fileFactory,
                   String filePrefix,
                   String fileExtension,
                   int maxAIO,
                   int userVersion,
                   IOCriticalErrorListener criticalErrorListener,
                   int maxAtticFiles)

Method Detail

isHistory
```
public boolean isHistory()
```
Specified by:

isHistory in interface Journal

setHistoryFolder

public JournalImpl setHistoryFolder(File historyFolder,
                                    long maxBytes,
                                    long period)
                             throws Exception

Specified by:: setHistoryFolder in interface Journal
Throws:: Exception

replaceableRecord
```
public void replaceableRecord(byte recordType)
```
This will declare a record type as being replaceable on updates. Certain update records only need the last value, and they could be replaceable during compacting.

Specified by:

replaceableRecord in interface Journal

getCompactPercentage
```
public float getCompactPercentage()
```

getCompactMinFiles
```
public int getCompactMinFiles()
```

getFilesRepository

public JournalFilesRepository getFilesRepository()

toString
```
public String toString()
```
Overrides:

toString in class Object

getCriticalErrorListener
```
public IOCriticalErrorListener getCriticalErrorListener()
```
Specified by:

getCriticalErrorListener in interface Journal

setCriticalErrorListener

public JournalImpl setCriticalErrorListener(IOCriticalErrorListener criticalErrorListener)

Specified by:: setCriticalErrorListener in interface Journal

getRecords
```
public ConcurrentLongHashMap<JournalRecord> getRecords()
```
Specified by:

getRecords in interface JournalRecordProvider

getCurrentFile
```
public JournalFile getCurrentFile()
```
Specified by:

getCurrentFile in interface TestableJournal

getCompactor
```
public JournalCompactor getCompactor()
```
Specified by:

getCompactor in interface JournalRecordProvider

orderFiles
```
public List<JournalFile> orderFiles()
                             throws Exception
```
this method is used internally only however tools may use it to maintenance. It won't be part of the interface as the tools should be specific to the implementation

Throws:

Exception

readJournalFile

public static int readJournalFile(SequentialFileFactory fileFactory,
                                  JournalFile file,
                                  JournalReaderCallback reader,
                                  AtomicReference<ByteBuffer> wholeFileBufferReference)
                           throws Exception

Throws:: Exception

readJournalFile

public static int readJournalFile(SequentialFileFactory fileFactory,
                                  JournalFile file,
                                  JournalReaderCallback reader,
                                  AtomicReference<ByteBuffer> wholeFileBufferReference,
                                  boolean reclaimed)
                           throws Exception

Throws:: Exception

readJournalFile

public static int readJournalFile(SequentialFileFactory fileFactory,
                                  JournalFile file,
                                  JournalReaderCallback reader,
                                  AtomicReference<ByteBuffer> wholeFileBufferReference,
                                  boolean reclaimed,
                                  io.netty.util.collection.ByteObjectHashMap<Boolean> replaceableRecords)
                           throws Exception

Throws:: Exception

readJournalFile

public static int readJournalFile(SequentialFileFactory fileFactory,
                                  JournalFile file,
                                  JournalReaderCallback reader)
                           throws Exception

this method is used internally only however tools may use it to maintenance.

Throws:: Exception

appendAddRecord

public void appendAddRecord(long id,
                            byte recordType,
                            Persister persister,
                            Object record,
                            boolean sync,
                            IOCompletion callback)
                     throws Exception

Specified by:: appendAddRecord in interface Journal
Throws:: Exception

appendAddEvent

public void appendAddEvent(long id,
                           byte recordType,
                           Persister persister,
                           Object record,
                           boolean sync,
                           IOCompletion callback)
                    throws Exception

Description copied from interface: Journal

An event is data recorded on the journal, but it won't have any weight or deletes. It's always ready to be removed. It is useful on recovery data while in use with backup history journal.

Specified by:: appendAddEvent in interface Journal
Throws:: Exception

appendUpdateRecord

public void appendUpdateRecord(long id,
                               byte recordType,
                               Persister persister,
                               Object record,
                               boolean sync,
                               IOCompletion callback)
                        throws Exception

Specified by:: appendUpdateRecord in interface Journal
Throws:: Exception

tryAppendUpdateRecord

public void tryAppendUpdateRecord(long id,
                                  byte recordType,
                                  Persister persister,
                                  Object record,
                                  boolean sync,
                                  boolean replaceableUpdate,
                                  JournalUpdateCallback updateCallback,
                                  IOCompletion callback)
                           throws Exception

Specified by:: tryAppendUpdateRecord in interface Journal
Throws:: Exception

appendDeleteRecord

public void appendDeleteRecord(long id,
                               boolean sync,
                               IOCompletion callback)
                        throws Exception

Specified by:: appendDeleteRecord in interface Journal
Throws:: Exception

tryAppendDeleteRecord

public void tryAppendDeleteRecord(long id,
                                  boolean sync,
                                  JournalUpdateCallback updateCallback,
                                  IOCompletion callback)
                           throws Exception

Specified by:: tryAppendDeleteRecord in interface Journal
Throws:: Exception

appendAddRecordTransactional

public void appendAddRecordTransactional(long txID,
                                         long id,
                                         byte recordType,
                                         Persister persister,
                                         Object record)
                                  throws Exception

Specified by:: appendAddRecordTransactional in interface Journal
Throws:: Exception

appendUpdateRecordTransactional

public void appendUpdateRecordTransactional(long txID,
                                            long id,
                                            byte recordType,
                                            Persister persister,
                                            Object record)
                                     throws Exception

Specified by:: appendUpdateRecordTransactional in interface Journal
Throws:: Exception

appendDeleteRecordTransactional

public void appendDeleteRecordTransactional(long txID,
                                            long id,
                                            EncodingSupport record)
                                     throws Exception

Specified by:: appendDeleteRecordTransactional in interface Journal
Throws:: Exception

appendPrepareRecord
```
public void appendPrepareRecord(long txID,
                                EncodingSupport transactionData,
                                boolean sync,
                                IOCompletion callback)
                         throws Exception
```
If the system crashed after a prepare was called, it should store information that is required to bring the transaction back to a state it could be committed.

transactionData allows you to store any other supporting user-data related to the transaction

This method also uses the same logic applied on Journal.appendCommitRecord(long, boolean)

Specified by:

appendPrepareRecord in interface Journal

Parameters:

txID -

transactionData - extra user data for the prepare

Throws:

Exception

lineUpContext
```
public void lineUpContext(IOCompletion callback)
```
Specified by:

lineUpContext in interface Journal

appendCommitRecord
```
public void appendCommitRecord(long txID,
                               boolean sync,
                               IOCompletion callback,
                               boolean lineUpContext)
                        throws Exception
```
Regarding the number of operations in a given file see JournalCompleteRecordTX.

Specified by:

appendCommitRecord in interface Journal

lineUpContext - if appendCommitRecord should call a storeLineUp. This is because the caller may have already taken into account

Throws:

Exception

appendRollbackRecord

public void appendRollbackRecord(long txID,
                                 boolean sync,
                                 IOCompletion callback)
                          throws Exception

Specified by:: appendRollbackRecord in interface Journal
Throws:: Exception

getAlignment
```
public int getAlignment()
                 throws Exception
```
Specified by:

getAlignment in interface Journal

Throws:

Exception

loadInternalOnly
```
public JournalLoadInformation loadInternalOnly()
                                        throws Exception
```
Description copied from interface: Journal

Load internal data structures and not expose any data. This is only useful if you're using the journal but not interested on the current data. Useful in situations where the journal is being replicated, copied... etc.

Specified by:

loadInternalOnly in interface Journal

Throws:

Exception

loadSyncOnly
```
public JournalLoadInformation loadSyncOnly(Journal.JournalState syncState)
                                    throws Exception
```
Description copied from interface: Journal

Load internal data structures, and remain waiting for synchronization to complete.

Specified by:

loadSyncOnly in interface Journal

Parameters:

syncState - the current state of the journal, this parameter ensures consistency.

Throws:

Exception

load

public JournalLoadInformation load(List<RecordInfo> committedRecords,
                                   List<PreparedTransactionInfo> preparedTransactions,
                                   TransactionFailureCallback transactionFailure,
                                   boolean fixBadTx)
                            throws Exception

Specified by:: load in interface Journal
Throws:: Exception

load

public JournalLoadInformation load(SparseArrayLinkedList<RecordInfo> committedRecords,
                                   List<PreparedTransactionInfo> preparedTransactions,
                                   TransactionFailureCallback failureCallback,
                                   boolean fixBadTX)
                            throws Exception

Specified by:: load in interface Journal
Throws:: Exception
See Also:: load(LoaderCallback)

scheduleCompactAndBlock
```
public void scheduleCompactAndBlock(int timeout)
                             throws Exception
```
Description copied from interface: Journal

This method will start compact using the compactorExecutor and block up to timeout seconds

Specified by:

scheduleCompactAndBlock in interface Journal

Parameters:

timeout - the timeout in seconds or block forever if <= 0

Throws:

Exception

compact
```
public void compact()
```
Note: This method can't be called from the main executor, as it will invoke other methods depending on it. Note: only synchronized methods on journal are methods responsible for the life-cycle such as stop, start records will still come as this is being executed

load

public JournalLoadInformation load(LoaderCallback loadManager)
                            throws Exception

Load data accordingly to the record layouts

Basic record layout:


Field Name	Size
RecordType	Byte (1)
FileID	Integer (4 bytes)
Compactor Counter	1 byte
TransactionID (if record is transactional)	Long (8 bytes)
RecordID	Long (8 bytes)
BodySize(Add, update and delete)	Integer (4 bytes)
UserDefinedRecordType (If add/update only)	Byte (1)
RecordBody	Byte Array (size=BodySize)
Check Size	Integer (4 bytes)

The check-size is used to validate if the record is valid and complete

Commit/Prepare record layout:


Field Name	Size
RecordType	Byte (1)
FileID	Integer (4 bytes)
Compactor Counter	1 byte
TransactionID (if record is transactional)	Long (8 bytes)
ExtraDataLength (Prepares only)	Integer (4 bytes)
Number Of Files (N)	Integer (4 bytes)
ExtraDataBytes	Bytes (sized by ExtraDataLength)
* FileID(n)	Integer (4 bytes)
* NumberOfElements(n)	Integer (4 bytes)
CheckSize	Integer (4 bytes)

* FileID and NumberOfElements are the transaction summary, and they will be repeated (N)umberOfFiles times

Specified by:: load in interface Journal
Throws:: Exception

processBackupCleanup
```
public void processBackupCleanup()
```
Description copied from interface: Journal

It will check max files and max days on files and remove extra files.

Specified by:

processBackupCleanup in interface Journal

processBackup
```
public void processBackup()
```
With the exception of initialization, this has to be always called within the compactorExecutor

Specified by:

processBackup in interface Journal

getHistoryFileName

public String getHistoryFileName(long sequence,
                                 Calendar calendar)

removeBackupExtension

public String removeBackupExtension(String name)

getDatePortionMillis

public long getDatePortionMillis(String name)

getDatePortion

public String getDatePortion(String name)

checkReclaimStatus
```
public final boolean checkReclaimStatus()
                                 throws Exception
```
Description copied from interface: TestableJournal

This method is called automatically when a new file is opened.
It will among other things, remove stale files and make them available for reuse.
This method locks the journal.

Specified by:

checkReclaimStatus in interface TestableJournal

Returns:

true if cleanup was called

Throws:

Exception

setAutoReclaim
```
public final void setAutoReclaim(boolean autoReclaim)
```
Specified by:

setAutoReclaim in interface TestableJournal

isAutoReclaim
```
public final boolean isAutoReclaim()
```
Specified by:

isAutoReclaim in interface TestableJournal

debug
```
public String debug()
             throws Exception
```
Specified by:

debug in interface TestableJournal

Throws:

Exception

debugWait
```
public void debugWait()
               throws InterruptedException
```
Method for use on testcases. It will call waitComplete on every transaction, so any assertions on the file system will be correct after this

Specified by:

debugWait in interface TestableJournal

Throws:

InterruptedException

flush
```
public void flush()
           throws Exception
```
Description copied from interface: Journal

It will make sure there are no more pending operations on the Executors.

Specified by:

flush in interface Journal

Throws:

Exception

getMaxRecordSize
```
public long getMaxRecordSize()
```
The max size record that can be stored in the journal

Specified by:

getMaxRecordSize in interface Journal

Returns:

flushAppendExecutor

public boolean flushAppendExecutor(long timeout,
                                   TimeUnit unit)
                            throws InterruptedException

Throws:: InterruptedException

getDataFilesCount
```
public int getDataFilesCount()
```
Specified by:

getDataFilesCount in interface TestableJournal

getDataFiles
```
public JournalFile[] getDataFiles()
```
Description copied from interface: Journal

Returns the JournalFiles in use.

Specified by:

getDataFiles in interface Journal

Specified by:

getDataFiles in interface TestableJournal

Returns:

array with all JournalFiles in use

getFreeFilesCount
```
public int getFreeFilesCount()
```
Specified by:

getFreeFilesCount in interface TestableJournal

getOpenedFilesCount
```
public int getOpenedFilesCount()
```
Specified by:

getOpenedFilesCount in interface TestableJournal

getIDMapSize
```
public int getIDMapSize()
```
Specified by:

getIDMapSize in interface TestableJournal

getFileSize
```
public int getFileSize()
```
Specified by:

getFileSize in interface Journal

Specified by:

getFileSize in interface TestableJournal

getMinFiles
```
public int getMinFiles()
```
Specified by:

getMinFiles in interface TestableJournal

getFilePrefix
```
public String getFilePrefix()
```
Specified by:

getFilePrefix in interface TestableJournal

getFileExtension
```
public String getFileExtension()
```
Specified by:

getFileExtension in interface TestableJournal

getMaxAIO
```
public int getMaxAIO()
```
Specified by:

getMaxAIO in interface TestableJournal

getUserVersion
```
public int getUserVersion()
```
Specified by:

getUserVersion in interface Journal

forceMoveNextFile
```
public void forceMoveNextFile()
                       throws Exception
```
Description copied from interface: Journal

Force the usage of a new JournalFile.

Specified by:

forceMoveNextFile in interface Journal

Specified by:

forceMoveNextFile in interface TestableJournal

Throws:

Exception

forceBackup

public void forceBackup(int timeout,
                        TimeUnit unit)
                 throws Exception

Specified by:: forceBackup in interface Journal
Throws:: Exception

isStarted
```
public boolean isStarted()
```
Specified by:

isStarted in interface ActiveMQComponent

start
```
public void start()
```
Specified by:

start in interface ActiveMQComponent

stop
```
public void stop()
          throws Exception
```
Specified by:

stop in interface ActiveMQComponent

Throws:

Exception

getNumberOfRecords
```
public int getNumberOfRecords()
```
Specified by:

getNumberOfRecords in interface Journal

createControlFile

protected SequentialFile createControlFile(List<JournalFile> files,
                                           List<JournalFile> newFiles,
                                           Pair<String,String> cleanupRename)
                                    throws Exception

Throws:: Exception

writeControlFile

protected SequentialFile writeControlFile(SequentialFileFactory fileFactory,
                                          List<JournalFile> files,
                                          List<JournalFile> newFiles,
                                          List<Pair<String,String>> renames)
                                   throws Exception

Throws:: Exception

deleteControlFile

protected void deleteControlFile(SequentialFile controlFile)
                          throws Exception

Throws:: Exception

renameFiles

protected void renameFiles(List<JournalFile> oldFiles,
                           List<JournalFile> newFiles)
                    throws Exception

being protected as testcases can override this method

Throws:: Exception

renameExtensionFile

protected static String renameExtensionFile(String name,
                                            String extension)

Parameters:: name -
Returns:

onCompactStart
```
protected void onCompactStart()
                       throws Exception
```
This is an interception point for testcases, when the compacted files are written, before replacing the data structures

Throws:

Exception

onCompactLockingTheJournal
```
protected void onCompactLockingTheJournal()
                                   throws Exception
```
This is an interception point for testcases, when the compacted files are written, to be called as soon as the compactor gets a writeLock

Throws:

Exception

onCompactDone
```
protected void onCompactDone()
```
This is an interception point for testcases, when the compacted files are written, before replacing the data structures

readFileHeader

public JournalFileImpl readFileHeader(SequentialFile file)
                               throws Exception

Parameters:: file -
Returns:
Throws:: Exception

initFileHeader

public static int initFileHeader(SequentialFileFactory fileFactory,
                                 SequentialFile sequentialFile,
                                 int userVersion,
                                 long fileID)
                          throws Exception

Parameters:: fileID -; sequentialFile -
Throws:: Exception

writeHeader

public static void writeHeader(ActiveMQBuffer buffer,
                               int userVersion,
                               long fileID)

Parameters:: buffer -; userVersion -; fileID -

synchronizationLock
```
public final void synchronizationLock()
```
Description copied from interface: Journal

Write lock the Journal and write lock the compacting process. Necessary only during replication for backup synchronization.

Specified by:

synchronizationLock in interface Journal

synchronizationUnlock
```
public final void synchronizationUnlock()
```
Description copied from interface: Journal

Unlock the Journal and the compacting process.

Specified by:

synchronizationUnlock in interface Journal

See Also:

Journal.synchronizationLock()

createFilesForBackupSync
```
public Map<Long,JournalFile> createFilesForBackupSync(long[] fileIds)
                                                     throws Exception
```
Returns Map with a JournalFile for all existing files. These are the files needed to be sent to a backup in order to synchronize it.

Specified by:

createFilesForBackupSync in interface Journal

Parameters:

fileIds -

Returns:

map with the IDs and corresponding JournalFiles

Throws:

Exception

getFileFactory
```
public SequentialFileFactory getFileFactory()
```
Specified by:

getFileFactory in interface Journal

setUpCurrentFile

protected JournalFile setUpCurrentFile(int lastDataPos)
                                throws Exception

Parameters:: lastDataPos -
Returns:
Throws:: Exception

switchFileIfNecessary

protected JournalFile switchFileIfNecessary(int size)
                                     throws Exception

Parameters:: size -
Returns:
Throws:: Exception

moveNextFile

protected void moveNextFile(boolean scheduleReclaim,
                            boolean blockOnClose)
                     throws Exception

You need to guarantee lock.acquire() before calling this method!

Throws:: Exception

replicationSyncPreserveOldFiles
```
public void replicationSyncPreserveOldFiles()
```
Description copied from interface: Journal

Stops any operation that may delete or modify old (stale) data.
Meant to be used during synchronization of data between a live server and its replicating (remote) backup. Old files must not be compacted or deleted during synchronization.

Specified by:

replicationSyncPreserveOldFiles in interface Journal

replicationSyncFinished
```
public void replicationSyncFinished()
```
Description copied from interface: Journal

Restarts file reclaim and compacting on the journal.
Meant to be used to revert the effect of Journal.replicationSyncPreserveOldFiles(). it should only be called once the synchronization of the backup and live servers is completed.

Specified by:

replicationSyncFinished in interface Journal

testCompact
```
public void testCompact()
```
Specified by:

testCompact in interface TestableJournal

getCompactCount
```
public int getCompactCount()
```
For tests only

setRemoveExtraFilesOnLoad
```
public void setRemoveExtraFilesOnLoad(boolean setting)
```
Specified by:

setRemoveExtraFilesOnLoad in interface Journal

isRemoveExtraFilesOnLoad
```
public boolean isRemoveExtraFilesOnLoad()
```
Specified by:

isRemoveExtraFilesOnLoad in interface Journal

appendAddRecord

public void appendAddRecord(long id,
                            byte recordType,
                            byte[] record,
                            boolean sync)
                     throws Exception

Specified by:: appendAddRecord in interface Journal
Throws:: Exception

appendAddRecord

public void appendAddRecord(long id,
                            byte recordType,
                            Persister persister,
                            Object record,
                            boolean sync)
                     throws Exception

Specified by:: appendAddRecord in interface Journal
Throws:: Exception

appendCommitRecord

public void appendCommitRecord(long txID,
                               boolean sync)
                        throws Exception

Specified by:: appendCommitRecord in interface Journal
Throws:: Exception

appendCommitRecord

public void appendCommitRecord(long txID,
                               boolean sync,
                               IOCompletion callback)
                        throws Exception

Specified by:: appendCommitRecord in interface Journal
Throws:: Exception

appendUpdateRecord

public void appendUpdateRecord(long id,
                               byte recordType,
                               byte[] record,
                               boolean sync)
                        throws Exception

Specified by:: appendUpdateRecord in interface Journal
Throws:: Exception

tryAppendUpdateRecord

public void tryAppendUpdateRecord(long id,
                                  byte recordType,
                                  byte[] record,
                                  JournalUpdateCallback updateCallback,
                                  boolean sync,
                                  boolean replaceableRecord)
                           throws Exception

Specified by:: tryAppendUpdateRecord in interface Journal
Throws:: Exception

appendUpdateRecordTransactional

public void appendUpdateRecordTransactional(long txID,
                                            long id,
                                            byte recordType,
                                            byte[] record)
                                     throws Exception

Specified by:: appendUpdateRecordTransactional in interface Journal
Throws:: Exception

appendAddRecordTransactional

public void appendAddRecordTransactional(long txID,
                                         long id,
                                         byte recordType,
                                         byte[] record)
                                  throws Exception

Specified by:: appendAddRecordTransactional in interface Journal
Throws:: Exception

appendDeleteRecordTransactional

public void appendDeleteRecordTransactional(long txID,
                                            long id)
                                     throws Exception

Specified by:: appendDeleteRecordTransactional in interface Journal
Throws:: Exception

appendPrepareRecord

public void appendPrepareRecord(long txID,
                                byte[] transactionData,
                                boolean sync)
                         throws Exception

Specified by:: appendPrepareRecord in interface Journal
Throws:: Exception

appendPrepareRecord
```
public void appendPrepareRecord(long txID,
                                EncodingSupport transactionData,
                                boolean sync)
                         throws Exception
```
Description copied from interface: Journal

If the system crashed after a prepare was called, it should store information that is required to bring the transaction back to a state it could be committed.

transactionData allows you to store any other supporting user-data related to the transaction

Specified by:

appendPrepareRecord in interface Journal

transactionData - - extra user data for the prepare

Throws:

Exception

appendDeleteRecordTransactional

public void appendDeleteRecordTransactional(long txID,
                                            long id,
                                            byte[] record)
                                     throws Exception

Specified by:: appendDeleteRecordTransactional in interface Journal
Throws:: Exception

appendUpdateRecord

public void appendUpdateRecord(long id,
                               byte recordType,
                               Persister persister,
                               Object record,
                               boolean sync)
                        throws Exception

Specified by:: appendUpdateRecord in interface Journal
Throws:: Exception

tryAppendUpdateRecord

public void tryAppendUpdateRecord(long id,
                                  byte recordType,
                                  Persister persister,
                                  Object record,
                                  JournalUpdateCallback updateCallback,
                                  boolean sync,
                                  boolean replaceableUpdate)
                           throws Exception

Specified by:: tryAppendUpdateRecord in interface Journal
Throws:: Exception

appendRollbackRecord

public void appendRollbackRecord(long txID,
                                 boolean sync)
                          throws Exception

Specified by:: appendRollbackRecord in interface Journal
Throws:: Exception

appendDeleteRecord

public void appendDeleteRecord(long id,
                               boolean sync)
                        throws Exception

Specified by:: appendDeleteRecord in interface Journal
Throws:: Exception

tryAppendDeleteRecord

public void tryAppendDeleteRecord(long id,
                                  JournalUpdateCallback updateCallback,
                                  boolean sync)
                           throws Exception

Specified by:: tryAppendDeleteRecord in interface Journal
Throws:: Exception

getSyncCallback

protected SyncIOCompletion getSyncCallback(boolean sync)

Class JournalImpl

Nested Class Summary

Nested classes/interfaces inherited from interface org.apache.activemq.artemis.core.journal.Journal

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.apache.activemq.artemis.core.server.ActiveMQComponent

Methods inherited from interface org.apache.activemq.artemis.core.journal.Journal

Field Detail

UPDATE_FACTOR

BKP

FORMAT_VERSION

MIN_FILE_SIZE

SIZE_HEADER

SIZE_ADD_RECORD

EVENT_RECORD

ADD_RECORD

UPDATE_RECORD

SIZE_ADD_RECORD_TX

ADD_RECORD_TX

UPDATE_RECORD_TX

SIZE_DELETE_RECORD_TX

DELETE_RECORD_TX

SIZE_DELETE_RECORD

DELETE_RECORD

SIZE_COMPLETE_TRANSACTION_RECORD

SIZE_PREPARE_RECORD

PREPARE_RECORD

SIZE_COMMIT_RECORD

COMMIT_RECORD

SIZE_ROLLBACK_RECORD

ROLLBACK_RECORD

FILL_CHARACTER

ioExecutorFactory

fileSize

removeExtraFilesOnLoad

Constructor Detail

JournalImpl

JournalImpl

JournalImpl

JournalImpl

JournalImpl

JournalImpl

Method Detail

isHistory

setHistoryFolder

replaceableRecord

getCompactPercentage

getCompactMinFiles

getFilesRepository

toString

getCriticalErrorListener

setCriticalErrorListener

getRecords

getCurrentFile

getCompactor

orderFiles

readJournalFile

readJournalFile

readJournalFile

readJournalFile

appendAddRecord

appendAddEvent

appendUpdateRecord

tryAppendUpdateRecord

appendDeleteRecord

tryAppendDeleteRecord

appendAddRecordTransactional

appendUpdateRecordTransactional

appendDeleteRecordTransactional

appendPrepareRecord

lineUpContext

appendCommitRecord

appendRollbackRecord

getAlignment

loadInternalOnly

loadSyncOnly

load

load