org.apache.activemq.artemis.core.io.SequentialFile

Here are the examples of the java api class org.apache.activemq.artemis.core.io.SequentialFile taken from open source projects.

1. PagingStoreImpl#createPage()

Project: activemq-artemis
File: PagingStoreImpl.java
@Override
public Page createPage(final int pageNumber) throws Exception {
    String fileName = createFileName(pageNumber);
    if (fileFactory == null) {
        fileFactory = storeFactory.newFileFactory(getStoreName());
    }
    SequentialFile file = fileFactory.createSequentialFile(fileName);
    Page page = new Page(storeName, storageManager, fileFactory, file, pageNumber);
    // To create the file
    file.open();
    file.position(0);
    file.close();
    return page;
}

2. JournalFilesRepository#reinitializeFile()

Project: activemq-artemis
File: JournalFilesRepository.java
// Discard the old JournalFile and set it with a new ID
private JournalFile reinitializeFile(final JournalFile file) throws Exception {
    long newFileID = generateFileID();
    SequentialFile sf = file.getFile();
    sf.open(1, false);
    int position = JournalImpl.initFileHeader(fileFactory, sf, userVersion, newFileID);
    JournalFile jf = new JournalFileImpl(sf, newFileID, JournalImpl.FORMAT_VERSION);
    sf.position(position);
    sf.close();
    return jf;
}

3. SequentialFileFactoryTestBase#testFill()

Project: activemq-artemis
File: SequentialFileFactoryTestBase.java
@Test
public void testFill() throws Exception {
    SequentialFile sf = factory.createSequentialFile("fill.amq");
    sf.open();
    try {
        checkFill(sf, 2048);
        checkFill(sf, 512);
        checkFill(sf, 512 * 4);
    } finally {
        sf.close();
    }
}

4. ReplicationManager#syncJournalFile()

Project: activemq-artemis
File: ReplicationManager.java
/**
    * Sends the whole content of the file to be duplicated.
    *
    * @throws ActiveMQException
    * @throws Exception
    */
public void syncJournalFile(JournalFile jf, AbstractJournalStorageManager.JournalContent content) throws Exception {
    if (!enabled) {
        return;
    }
    SequentialFile file = jf.getFile().cloneFile();
    try {
        ActiveMQServerLogger.LOGGER.journalSynch(jf, file.size(), file);
        sendLargeFile(content, null, jf.getFileID(), file, Long.MAX_VALUE);
    } finally {
        if (file.isOpen())
            file.close();
    }
}

5. FileIOUtilTest#testCopy()

Project: activemq-artemis
File: FileIOUtilTest.java
@Test
public void testCopy() throws Exception {
    System.out.println("Data at " + temporaryFolder.getRoot());
    SequentialFileFactory factory = new NIOSequentialFileFactory(temporaryFolder.getRoot(), 100);
    SequentialFile file = factory.createSequentialFile("file1.bin");
    file.open();
    ByteBuffer buffer = ByteBuffer.allocate(204800);
    buffer.put(new byte[204800]);
    buffer.rewind();
    file.writeDirect(buffer, true);
    buffer = ByteBuffer.allocate(409605);
    buffer.put(new byte[409605]);
    buffer.rewind();
    SequentialFile file2 = factory.createSequentialFile("file2.bin");
    file2.open();
    file2.writeDirect(buffer, true);
    // This is allocating a reusable buffer to perform the copy, just like it's used within LargeMessageInSync
    buffer = ByteBuffer.allocate(4 * 1024);
    SequentialFile newFile = factory.createSequentialFile("file1.cop");
    FileIOUtil.copyData(file, newFile, buffer);
    SequentialFile newFile2 = factory.createSequentialFile("file2.cop");
    FileIOUtil.copyData(file2, newFile2, buffer);
    Assert.assertEquals(file.size(), newFile.size());
    Assert.assertEquals(file2.size(), newFile2.size());
    newFile.close();
    newFile2.close();
    file.close();
    file2.close();
    System.out.println("Test result::");
}

6. SequentialFileFactoryTestBase#testOpenClose()

Project: activemq-artemis
File: SequentialFileFactoryTestBase.java
@Test
public void testOpenClose() throws Exception {
    SequentialFile sf = factory.createSequentialFile("openclose.amq");
    sf.open();
    sf.fill(512);
    String s1 = "cheesecake";
    byte[] bytes1 = s1.getBytes(StandardCharsets.UTF_8);
    long initialPos = sf.position();
    sf.write(wrapBuffer(bytes1), true);
    long bytesWritten = sf.position() - initialPos;
    Assert.assertEquals(calculateRecordSize(bytes1.length, sf.getAlignment()), bytesWritten);
    sf.close();
    try {
        sf.write(wrapBuffer(bytes1), true);
        Assert.fail("Should throw exception");
    } catch (Exception e) {
    }
    sf.open();
    sf.write(wrapBuffer(bytes1), true);
    sf.close();
}

7. SequentialFileFactoryTestBase#testWriteandRead()

Project: activemq-artemis
File: SequentialFileFactoryTestBase.java
@Test
public void testWriteandRead() throws Exception {
    SequentialFile sf = factory.createSequentialFile("write.amq");
    sf.open();
    String s1 = "aardvark";
    byte[] bytes1 = s1.getBytes(StandardCharsets.UTF_8);
    ActiveMQBuffer bb1 = wrapBuffer(bytes1);
    String s2 = "hippopotamus";
    byte[] bytes2 = s2.getBytes(StandardCharsets.UTF_8);
    ActiveMQBuffer bb2 = wrapBuffer(bytes2);
    String s3 = "echidna";
    byte[] bytes3 = s3.getBytes(StandardCharsets.UTF_8);
    ActiveMQBuffer bb3 = wrapBuffer(bytes3);
    long initialPos = sf.position();
    sf.write(bb1, true);
    long bytesWritten = sf.position() - initialPos;
    Assert.assertEquals(calculateRecordSize(bytes1.length, sf.getAlignment()), bytesWritten);
    initialPos = sf.position();
    sf.write(bb2, true);
    bytesWritten = sf.position() - initialPos;
    Assert.assertEquals(calculateRecordSize(bytes2.length, sf.getAlignment()), bytesWritten);
    initialPos = sf.position();
    sf.write(bb3, true);
    bytesWritten = sf.position() - initialPos;
    Assert.assertEquals(calculateRecordSize(bytes3.length, sf.getAlignment()), bytesWritten);
    sf.position(0);
    ByteBuffer rb1 = factory.newBuffer(bytes1.length);
    ByteBuffer rb2 = factory.newBuffer(bytes2.length);
    ByteBuffer rb3 = factory.newBuffer(bytes3.length);
    int bytesRead = sf.read(rb1);
    Assert.assertEquals(calculateRecordSize(bytes1.length, sf.getAlignment()), bytesRead);
    for (int i = 0; i < bytes1.length; i++) {
        Assert.assertEquals(bytes1[i], rb1.get(i));
    }
    bytesRead = sf.read(rb2);
    Assert.assertEquals(calculateRecordSize(bytes2.length, sf.getAlignment()), bytesRead);
    for (int i = 0; i < bytes2.length; i++) {
        Assert.assertEquals(bytes2[i], rb2.get(i));
    }
    bytesRead = sf.read(rb3);
    Assert.assertEquals(calculateRecordSize(bytes3.length, sf.getAlignment()), bytesRead);
    for (int i = 0; i < bytes3.length; i++) {
        Assert.assertEquals(bytes3[i], rb3.get(i));
    }
    sf.close();
}

8. AlignedJournalImplTest#testReloadInvalidPrepared()

Project: activemq-artemis
File: AlignedJournalImplTest.java
@Test
public void testReloadInvalidPrepared() throws Exception {
    final int JOURNAL_SIZE = 3000;
    setupAndLoadJournal(JOURNAL_SIZE, 100);
    Assert.assertEquals(0, records.size());
    Assert.assertEquals(0, transactions.size());
    for (int i = 0; i < 10; i++) {
        journalImpl.appendAddRecordTransactional(1, i, (byte) 1, new SimpleEncoding(50, (byte) 1));
    }
    journalImpl.appendPrepareRecord(1L, new SimpleEncoding(13, (byte) 0), false);
    setupAndLoadJournal(JOURNAL_SIZE, 100);
    Assert.assertEquals(0, records.size());
    Assert.assertEquals(1, transactions.size());
    SequentialFile file = factory.createSequentialFile("tt-1.tt");
    file.open();
    ByteBuffer buffer = ByteBuffer.allocate(100);
    // Messing up with the first record (removing the position)
    file.position(100);
    file.read(buffer);
    buffer.position(1);
    buffer.putInt(-1);
    buffer.rewind();
    // Messing up with the first record (changing the fileID, so Journal
    // reload will think the record came from a different journal usage)
    file.position(100);
    file.writeDirect(buffer, true);
    file.close();
    setupAndLoadJournal(JOURNAL_SIZE, 100);
    Assert.assertEquals(0, records.size());
    Assert.assertEquals(0, transactions.size());
}

9. AlignedJournalImplTest#testReloadIncompleteTransaction()

Project: activemq-artemis
File: AlignedJournalImplTest.java
@Test
public void testReloadIncompleteTransaction() throws Exception {
    final int JOURNAL_SIZE = 2000;
    setupAndLoadJournal(JOURNAL_SIZE, 1);
    Assert.assertEquals(2, factory.listFiles("tt").size());
    Assert.assertEquals(0, records.size());
    Assert.assertEquals(0, transactions.size());
    for (int i = 0; i < 10; i++) {
        journalImpl.appendAddRecordTransactional(1L, i, (byte) 0, new SimpleEncoding(1, (byte) 15));
    }
    for (int i = 10; i < 20; i++) {
        journalImpl.appendAddRecordTransactional(1L, i, (byte) 0, new SimpleEncoding(1, (byte) 15));
    }
    journalImpl.appendCommitRecord(1L, false);
    SequentialFile file = factory.createSequentialFile("tt-1.tt");
    file.open();
    ByteBuffer buffer = ByteBuffer.allocate(100);
    // Messing up with the first record (removing the position)
    file.position(100);
    file.read(buffer);
    buffer.position(1);
    buffer.putInt(-1);
    buffer.rewind();
    // Messing up with the first record (changing the fileID, so Journal
    // reload will think the record came from a different journal usage)
    file.position(100);
    buffer.rewind();
    file.writeDirect(buffer, true);
    file.close();
    setupAndLoadJournal(JOURNAL_SIZE, 100);
    Assert.assertEquals(0, records.size());
    journalImpl.checkReclaimStatus();
    Assert.assertEquals(0, journalImpl.getDataFilesCount());
    Assert.assertEquals(2, factory.listFiles("tt").size());
}

10. AlignedJournalImplTest#testPartiallyBrokenFile()

Project: activemq-artemis
File: AlignedJournalImplTest.java
@Test
public void testPartiallyBrokenFile() throws Exception {
    final int JOURNAL_SIZE = 20000;
    setupAndLoadJournal(JOURNAL_SIZE, 100);
    Assert.assertEquals(2, factory.listFiles("tt").size());
    Assert.assertEquals(0, records.size());
    Assert.assertEquals(0, transactions.size());
    for (int i = 0; i < 20; i++) {
        journalImpl.appendAddRecordTransactional(1L, i, (byte) 0, new SimpleEncoding(1, (byte) 15));
        journalImpl.appendAddRecordTransactional(2L, i + 20L, (byte) 0, new SimpleEncoding(1, (byte) 15));
    }
    journalImpl.appendCommitRecord(1L, false);
    journalImpl.appendCommitRecord(2L, false);
    SequentialFile file = factory.createSequentialFile("tt-1.tt");
    file.open();
    ByteBuffer buffer = ByteBuffer.allocate(100);
    // Messing up with the first record (removing the position)
    file.position(100);
    file.read(buffer);
    // jumping RecordType, FileId, TransactionID, RecordID, VariableSize,
    // RecordType, RecordBody (that we know it is 1 )
    buffer.position(1 + 4 + 8 + 8 + 4 + 1 + 1 + 1);
    int posCheckSize = buffer.position();
    Assert.assertEquals(JournalImpl.SIZE_ADD_RECORD_TX + 2, buffer.getInt());
    buffer.position(posCheckSize);
    buffer.putInt(-1);
    buffer.rewind();
    // Changing the check bufferSize, so reload will ignore this record
    file.position(100);
    file.writeDirect(buffer, true);
    file.close();
    setupAndLoadJournal(JOURNAL_SIZE, 100);
    Assert.assertEquals(20, records.size());
    journalImpl.checkReclaimStatus();
}

11. AlignedJournalImplTest#testReloadInvalidCheckSizeOnTransaction()

Project: activemq-artemis
File: AlignedJournalImplTest.java
@Test
public void testReloadInvalidCheckSizeOnTransaction() throws Exception {
    final int JOURNAL_SIZE = 2000;
    setupAndLoadJournal(JOURNAL_SIZE, 100);
    Assert.assertEquals(2, factory.listFiles("tt").size());
    Assert.assertEquals(0, records.size());
    Assert.assertEquals(0, transactions.size());
    for (int i = 0; i < 2; i++) {
        journalImpl.appendAddRecordTransactional(1L, i, (byte) 0, new SimpleEncoding(1, (byte) 15));
    }
    journalImpl.appendCommitRecord(1L, false);
    System.out.println("Files = " + factory.listFiles("tt"));
    SequentialFile file = factory.createSequentialFile("tt-1.tt");
    file.open();
    ByteBuffer buffer = ByteBuffer.allocate(100);
    // Messing up with the first record (removing the position)
    file.position(100);
    file.read(buffer);
    // jumping RecordType, FileId, TransactionID, RecordID, VariableSize,
    // RecordType, RecordBody (that we know it is 1 )
    buffer.position(1 + 4 + 8 + 8 + 4 + 1 + 1 + 1);
    int posCheckSize = buffer.position();
    Assert.assertEquals(JournalImpl.SIZE_ADD_RECORD_TX + 2, buffer.getInt());
    buffer.position(posCheckSize);
    buffer.putInt(-1);
    buffer.rewind();
    // Changing the check bufferSize, so reload will ignore this record
    file.position(100);
    file.writeDirect(buffer, true);
    file.close();
    setupAndLoadJournal(JOURNAL_SIZE, 100);
    Assert.assertEquals(0, records.size());
    journalImpl.checkReclaimStatus();
    Assert.assertEquals(0, journalImpl.getDataFilesCount());
    Assert.assertEquals(2, factory.listFiles("tt").size());
}

12. SequentialFileFactoryTestBase#testDelete()

Project: activemq-artemis
File: SequentialFileFactoryTestBase.java
@Test
public void testDelete() throws Exception {
    SequentialFile sf = factory.createSequentialFile("delete-me.amq");
    sf.open();
    SequentialFile sf2 = factory.createSequentialFile("delete-me2.amq");
    sf2.open();
    List<String> fileNames = factory.listFiles("amq");
    Assert.assertEquals(2, fileNames.size());
    Assert.assertTrue(fileNames.contains("delete-me.amq"));
    Assert.assertTrue(fileNames.contains("delete-me2.amq"));
    sf.delete();
    fileNames = factory.listFiles("amq");
    Assert.assertEquals(1, fileNames.size());
    Assert.assertTrue(fileNames.contains("delete-me2.amq"));
    sf2.close();
}

13. SequentialFileFactoryTestBase#testCreateAndListFiles()

Project: activemq-artemis
File: SequentialFileFactoryTestBase.java
@Test
public void testCreateAndListFiles() throws Exception {
    List<String> expectedFiles = new ArrayList<>();
    final int numFiles = 10;
    for (int i = 0; i < numFiles; i++) {
        String fileName = UUID.randomUUID().toString() + ".amq";
        expectedFiles.add(fileName);
        SequentialFile sf = factory.createSequentialFile(fileName);
        sf.open();
        Assert.assertEquals(fileName, sf.getFileName());
        sf.close();
    }
    // Create a couple with a different extension - they shouldn't be picked
    // up
    SequentialFile sf1 = factory.createSequentialFile("different.file");
    sf1.open();
    SequentialFile sf2 = factory.createSequentialFile("different.cheese");
    sf2.open();
    List<String> fileNames = factory.listFiles("amq");
    Assert.assertEquals(expectedFiles.size(), fileNames.size());
    for (String fileName : expectedFiles) {
        Assert.assertTrue(fileNames.contains(fileName));
    }
    fileNames = factory.listFiles("file");
    Assert.assertEquals(1, fileNames.size());
    Assert.assertTrue(fileNames.contains("different.file"));
    fileNames = factory.listFiles("cheese");
    Assert.assertEquals(1, fileNames.size());
    Assert.assertTrue(fileNames.contains("different.cheese"));
    sf1.close();
    sf2.close();
}

14. PageTest#testDamagedPage()

Project: activemq-artemis
File: PageTest.java
protected void testDamagedPage(final SequentialFileFactory factory, final int numberOfElements) throws Exception {
    SequentialFile file = factory.createSequentialFile("00010.page");
    Page impl = new Page(new SimpleString("something"), new NullStorageManager(), factory, file, 10);
    Assert.assertEquals(10, impl.getPageId());
    impl.open();
    Assert.assertEquals(1, factory.listFiles("page").size());
    SimpleString simpleDestination = new SimpleString("Test");
    ArrayList<ActiveMQBuffer> buffers = addPageElements(simpleDestination, impl, numberOfElements);
    impl.sync();
    long positionA = file.position();
    // Add one record that will be damaged
    addPageElements(simpleDestination, impl, 1);
    long positionB = file.position();
    // Add more 10 as they will need to be ignored
    addPageElements(simpleDestination, impl, 10);
    // Damage data... position the file on the middle between points A and B
    file.position(positionA + (positionB - positionA) / 2);
    ByteBuffer buffer = ByteBuffer.allocate((int) (positionB - file.position()));
    for (int i = 0; i < buffer.capacity(); i++) {
        buffer.put((byte) 'Z');
    }
    buffer.rewind();
    file.writeDirect(buffer, true);
    impl.close();
    file = factory.createSequentialFile("00010.page");
    file.open();
    impl = new Page(new SimpleString("something"), new NullStorageManager(), factory, file, 10);
    List<PagedMessage> msgs = impl.read(new NullStorageManager());
    Assert.assertEquals(numberOfElements, msgs.size());
    Assert.assertEquals(numberOfElements, impl.getNumberOfMessages());
    for (int i = 0; i < msgs.size(); i++) {
        Assert.assertEquals(simpleDestination, msgs.get(i).getMessage().getAddress());
        ActiveMQTestBase.assertEqualsByteArrays(buffers.get(i).toByteBuffer().array(), msgs.get(i).getMessage().getBodyBuffer().toByteBuffer().array());
    }
    impl.delete(null);
    Assert.assertEquals(0, factory.listFiles("page").size());
    Assert.assertEquals(1, factory.listFiles("invalidPage").size());
}

15. SequentialFileFactoryTestBase#testRename()

Project: activemq-artemis
File: SequentialFileFactoryTestBase.java
@Test
public void testRename() throws Exception {
    SequentialFile sf = factory.createSequentialFile("test1.amq");
    sf.open();
    List<String> fileNames = factory.listFiles("amq");
    Assert.assertEquals(1, fileNames.size());
    Assert.assertTrue(fileNames.contains("test1.amq"));
    sf.renameTo("test1.cmp");
    fileNames = factory.listFiles("cmp");
    Assert.assertEquals(1, fileNames.size());
    Assert.assertTrue(fileNames.contains("test1.cmp"));
    sf.delete();
    fileNames = factory.listFiles("amq");
    Assert.assertEquals(0, fileNames.size());
    fileNames = factory.listFiles("cmp");
    Assert.assertEquals(0, fileNames.size());
}

16. JournalFilesRepository#createFile0()

Project: activemq-artemis
File: JournalFilesRepository.java
private JournalFile createFile0(final boolean keepOpened, final boolean multiAIO, final boolean init, final boolean tmpCompact, final long fileIdPreSet) throws Exception {
    long fileID = fileIdPreSet != -1 ? fileIdPreSet : generateFileID();
    final String fileName = createFileName(tmpCompact, fileID);
    if (logger.isTraceEnabled()) {
        logger.trace("Creating file " + fileName);
    }
    String tmpFileName = fileName + ".tmp";
    SequentialFile sequentialFile = fileFactory.createSequentialFile(tmpFileName);
    sequentialFile.open(1, false);
    if (init) {
        sequentialFile.fill(fileSize);
        JournalImpl.initFileHeader(fileFactory, sequentialFile, userVersion, fileID);
    }
    long position = sequentialFile.position();
    sequentialFile.close();
    if (logger.isTraceEnabled()) {
        logger.trace("Renaming file " + tmpFileName + " as " + fileName);
    }
    sequentialFile.renameTo(fileName);
    if (keepOpened) {
        if (multiAIO) {
            sequentialFile.open();
        } else {
            sequentialFile.open(1, false);
        }
        sequentialFile.position(position);
    }
    return new JournalFileImpl(sequentialFile, fileID, JournalImpl.FORMAT_VERSION);
}

17. AIOSequentialFileFactoryTest#testBuffer()

Project: activemq-artemis
File: AIOSequentialFileFactoryTest.java
@Test
public void testBuffer() throws Exception {
    SequentialFile file = factory.createSequentialFile("filtetmp.log");
    file.open();
    ByteBuffer buff = factory.newBuffer(10);
    Assert.assertEquals(512, buff.limit());
    file.close();
    factory.releaseBuffer(buff);
}

18. PageTest#testAdd()

Project: activemq-artemis
File: PageTest.java
/**
    * Validate if everything we add is recovered
    */
protected void testAdd(final SequentialFileFactory factory, final int numberOfElements) throws Exception {
    SequentialFile file = factory.createSequentialFile("00010.page");
    Page impl = new Page(new SimpleString("something"), new NullStorageManager(), factory, file, 10);
    Assert.assertEquals(10, impl.getPageId());
    impl.open();
    Assert.assertEquals(1, factory.listFiles("page").size());
    SimpleString simpleDestination = new SimpleString("Test");
    ArrayList<ActiveMQBuffer> buffers = addPageElements(simpleDestination, impl, numberOfElements);
    impl.sync();
    impl.close();
    file = factory.createSequentialFile("00010.page");
    file.open();
    impl = new Page(new SimpleString("something"), new NullStorageManager(), factory, file, 10);
    List<PagedMessage> msgs = impl.read(new NullStorageManager());
    Assert.assertEquals(numberOfElements, msgs.size());
    Assert.assertEquals(numberOfElements, impl.getNumberOfMessages());
    for (int i = 0; i < msgs.size(); i++) {
        Assert.assertEquals(simpleDestination, msgs.get(i).getMessage().getAddress());
        ActiveMQTestBase.assertEqualsByteArrays(buffers.get(i).toByteBuffer().array(), msgs.get(i).getMessage().getBodyBuffer().toByteBuffer().array());
    }
    impl.delete(null);
    Assert.assertEquals(0, factory.listFiles(".page").size());
}

19. SequentialFileFactoryTestBase#testPosition()

Project: activemq-artemis
File: SequentialFileFactoryTestBase.java
@Test
public void testPosition() throws Exception {
    SequentialFile sf = factory.createSequentialFile("position.amq");
    sf.open();
    try {
        sf.fill(3 * 512);
        String s1 = "orange";
        byte[] bytes1 = s1.getBytes(StandardCharsets.UTF_8);
        byte[] bytes2 = s1.getBytes(StandardCharsets.UTF_8);
        String s3 = "lemon";
        byte[] bytes3 = s3.getBytes(StandardCharsets.UTF_8);
        long initialPos = sf.position();
        sf.write(wrapBuffer(bytes1), true);
        long bytesWritten = sf.position() - initialPos;
        Assert.assertEquals(calculateRecordSize(bytes1.length, sf.getAlignment()), bytesWritten);
        initialPos = sf.position();
        sf.write(wrapBuffer(bytes2), true);
        bytesWritten = sf.position() - initialPos;
        Assert.assertEquals(calculateRecordSize(bytes2.length, sf.getAlignment()), bytesWritten);
        initialPos = sf.position();
        sf.write(wrapBuffer(bytes3), true);
        bytesWritten = sf.position() - initialPos;
        Assert.assertEquals(calculateRecordSize(bytes3.length, sf.getAlignment()), bytesWritten);
        byte[] rbytes1 = new byte[bytes1.length];
        byte[] rbytes2 = new byte[bytes2.length];
        byte[] rbytes3 = new byte[bytes3.length];
        ByteBuffer rb1 = factory.newBuffer(rbytes1.length);
        ByteBuffer rb2 = factory.newBuffer(rbytes2.length);
        ByteBuffer rb3 = factory.newBuffer(rbytes3.length);
        sf.position(calculateRecordSize(bytes1.length, sf.getAlignment()) + calculateRecordSize(bytes2.length, sf.getAlignment()));
        int bytesRead = sf.read(rb3);
        Assert.assertEquals(rb3.limit(), bytesRead);
        rb3.rewind();
        rb3.get(rbytes3);
        ActiveMQTestBase.assertEqualsByteArrays(bytes3, rbytes3);
        sf.position(rb1.limit());
        bytesRead = sf.read(rb2);
        Assert.assertEquals(rb2.limit(), bytesRead);
        rb2.get(rbytes2);
        ActiveMQTestBase.assertEqualsByteArrays(bytes2, rbytes2);
        sf.position(0);
        bytesRead = sf.read(rb1);
        Assert.assertEquals(rb1.limit(), bytesRead);
        rb1.get(rbytes1);
        ActiveMQTestBase.assertEqualsByteArrays(bytes1, rbytes1);
    } finally {
        try {
            sf.close();
        } catch (Exception ignored) {
        }
    }
}

20. AlignedJournalImplTest#testBasicAlignment()

Project: activemq-artemis
File: AlignedJournalImplTest.java
// Static --------------------------------------------------------
// Constructors --------------------------------------------------
// Public --------------------------------------------------------
// This test just validates basic alignment on the FakeSequentialFile itself
@Test
public void testBasicAlignment() throws Exception {
    FakeSequentialFileFactory factory = new FakeSequentialFileFactory(200, true);
    SequentialFile file = factory.createSequentialFile("test1");
    file.open();
    try {
        ByteBuffer buffer = ByteBuffer.allocateDirect(200);
        for (int i = 0; i < 200; i++) {
            buffer.put(i, (byte) 1);
        }
        file.writeDirect(buffer, true);
        buffer = ByteBuffer.allocate(400);
        for (int i = 0; i < 400; i++) {
            buffer.put(i, (byte) 2);
        }
        file.writeDirect(buffer, true);
        buffer = ByteBuffer.allocate(600);
        file.position(0);
        file.read(buffer);
        for (int i = 0; i < 200; i++) {
            Assert.assertEquals((byte) 1, buffer.get(i));
        }
        for (int i = 201; i < 600; i++) {
            Assert.assertEquals("Position " + i, (byte) 2, buffer.get(i));
        }
    } catch (Exception ignored) {
    }
}

21. ReplicationEndpoint#handleReplicationSynchronization()

Project: activemq-artemis
File: ReplicationEndpoint.java
/**
    * Receives 'raw' journal/page/large-message data from live server for synchronization of logs.
    *
    * @param msg
    * @throws Exception
    */
private void handleReplicationSynchronization(ReplicationSyncFileMessage msg) throws Exception {
    Long id = Long.valueOf(msg.getId());
    byte[] data = msg.getData();
    SequentialFile channel1;
    switch(msg.getFileType()) {
        case LARGE_MESSAGE:
            {
                ReplicatedLargeMessage largeMessage = lookupLargeMessage(id, false, false);
                if (!(largeMessage instanceof LargeServerMessageInSync)) {
                    ActiveMQServerLogger.LOGGER.largeMessageIncompatible();
                    return;
                }
                LargeServerMessageInSync largeMessageInSync = (LargeServerMessageInSync) largeMessage;
                channel1 = largeMessageInSync.getSyncFile();
                break;
            }
        case PAGE:
            {
                Page page = getPage(msg.getPageStore(), (int) msg.getId());
                channel1 = page.getFile();
                break;
            }
        case JOURNAL:
            {
                JournalSyncFile journalSyncFile = filesReservedForSync.get(msg.getJournalContent()).get(id);
                FileChannel channel2 = journalSyncFile.getChannel();
                if (data == null) {
                    channel2.close();
                    return;
                }
                channel2.write(ByteBuffer.wrap(data));
                return;
            }
        default:
            throw ActiveMQMessageBundle.BUNDLE.replicationUnhandledFileType(msg.getFileType());
    }
    if (data == null) {
        return;
    }
    if (!channel1.isOpen()) {
        channel1.open();
    }
    channel1.writeDirect(ByteBuffer.wrap(data), true);
}

22. PagingStoreImpl#checkPageFileExists()

Project: activemq-artemis
File: PagingStoreImpl.java
@Override
public boolean checkPageFileExists(final int pageNumber) {
    String fileName = createFileName(pageNumber);
    SequentialFile file = fileFactory.createSequentialFile(fileName);
    return file.exists();
}

23. JournalCompactor#readControlFile()

Project: activemq-artemis
File: JournalCompactor.java
public static SequentialFile readControlFile(final SequentialFileFactory fileFactory, final List<String> dataFiles, final List<String> newFiles, final List<Pair<String, String>> renameFile) throws Exception {
    SequentialFile controlFile = fileFactory.createSequentialFile(AbstractJournalUpdateTask.FILE_COMPACT_CONTROL);
    if (controlFile.exists()) {
        JournalFile file = new JournalFileImpl(controlFile, 0, JournalImpl.FORMAT_VERSION);
        final ArrayList<RecordInfo> records = new ArrayList<>();
        JournalImpl.readJournalFile(fileFactory, file, new JournalReaderCallbackAbstract() {

            @Override
            public void onReadAddRecord(final RecordInfo info) throws Exception {
                records.add(info);
            }
        });
        if (records.size() == 0) {
            return null;
        } else {
            ActiveMQBuffer input = ActiveMQBuffers.wrappedBuffer(records.get(0).data);
            int numberDataFiles = input.readInt();
            for (int i = 0; i < numberDataFiles; i++) {
                dataFiles.add(input.readUTF());
            }
            int numberNewFiles = input.readInt();
            for (int i = 0; i < numberNewFiles; i++) {
                newFiles.add(input.readUTF());
            }
            int numberRenames = input.readInt();
            for (int i = 0; i < numberRenames; i++) {
                String from = input.readUTF();
                String to = input.readUTF();
                renameFile.add(new Pair<>(from, to));
            }
        }
        return controlFile;
    } else {
        return null;
    }
}

24. LargeServerMessageInSync#joinSyncedData()

Project: activemq-artemis
File: LargeServerMessageInSync.java
public synchronized void joinSyncedData(ByteBuffer buffer) throws Exception {
    if (deleted)
        return;
    SequentialFile mainSeqFile = mainLM.getFile();
    if (!mainSeqFile.isOpen()) {
        mainSeqFile.open();
    }
    try {
        if (appendFile != null) {
            if (logger.isTraceEnabled()) {
                logger.trace("joinSyncedData on " + mainLM + ", currentSize on mainMessage=" + mainSeqFile.size() + ", appendFile size = " + appendFile.size());
            }
            FileIOUtil.copyData(appendFile, mainSeqFile, buffer);
            deleteAppendFile();
        } else {
            if (logger.isTraceEnabled()) {
                logger.trace("joinSyncedData, appendFile is null, ignoring joinSyncedData on " + mainLM);
            }
        }
    } catch (Throwable e) {
        logger.warn("Error while sincing data on largeMessageInSync::" + mainLM);
    }
    if (logger.isTraceEnabled()) {
        logger.trace("joinedSyncData on " + mainLM + " finished with " + mainSeqFile.size());
    }
    syncDone = true;
}

25. LargeServerMessageImpl#copy()

Project: activemq-artemis
File: LargeServerMessageImpl.java
@Override
public ServerMessage copy() {
    SequentialFile newfile = storageManager.createFileForLargeMessage(messageID, durable);
    ServerMessage newMessage = new LargeServerMessageImpl(this, properties, newfile, messageID);
    return newMessage;
}

26. JournalStorageManager#deleteLargeMessageFile()

Project: activemq-artemis
File: JournalStorageManager.java
// This should be accessed from this package only
void deleteLargeMessageFile(final LargeServerMessage largeServerMessage) throws ActiveMQException {
    if (largeServerMessage.getPendingRecordID() < 0) {
        try {
            // The delete file happens asynchronously
            // And the client won't be waiting for the actual file to be deleted.
            // We set a temporary record (short lived) on the journal
            // to avoid a situation where the server is restarted and pending large message stays on forever
            largeServerMessage.setPendingRecordID(storePendingLargeMessage(largeServerMessage.getMessageID()));
        } catch (Exception e) {
            throw new ActiveMQInternalErrorException(e.getMessage(), e);
        }
    }
    final SequentialFile file = largeServerMessage.getFile();
    if (file == null) {
        return;
    }
    if (largeServerMessage.isDurable() && isReplicated()) {
        readLock();
        try {
            if (isReplicated() && replicator.isSynchronizing()) {
                synchronized (largeMessagesToDelete) {
                    largeMessagesToDelete.add(Long.valueOf(largeServerMessage.getMessageID()));
                    confirmLargeMessage(largeServerMessage);
                }
                return;
            }
        } finally {
            readUnLock();
        }
    }
    Runnable deleteAction = new Runnable() {

        @Override
        public void run() {
            try {
                readLock();
                try {
                    if (replicator != null) {
                        replicator.largeMessageDelete(largeServerMessage.getMessageID());
                    }
                    file.delete();
                    // The confirm could only be done after the actual delete is done
                    confirmLargeMessage(largeServerMessage);
                } finally {
                    readUnLock();
                }
            } catch (Exception e) {
                ActiveMQServerLogger.LOGGER.journalErrorDeletingMessage(e, largeServerMessage.getMessageID());
            }
        }
    };
    if (executor == null) {
        deleteAction.run();
    } else {
        executor.execute(deleteAction);
    }
}

27. JournalImpl#checkControlFile()

Project: activemq-artemis
File: JournalImpl.java
/**
    * @throws Exception
    */
private void checkControlFile() throws Exception {
    ArrayList<String> dataFiles = new ArrayList<>();
    ArrayList<String> newFiles = new ArrayList<>();
    ArrayList<Pair<String, String>> renames = new ArrayList<>();
    SequentialFile controlFile = JournalCompactor.readControlFile(fileFactory, dataFiles, newFiles, renames);
    if (controlFile != null) {
        for (String dataFile : dataFiles) {
            SequentialFile file = fileFactory.createSequentialFile(dataFile);
            if (file.exists()) {
                file.delete();
            }
        }
        for (String newFile : newFiles) {
            SequentialFile file = fileFactory.createSequentialFile(newFile);
            if (file.exists()) {
                final String originalName = file.getFileName();
                final String newName = originalName.substring(0, originalName.lastIndexOf(".cmp"));
                file.renameTo(newName);
            }
        }
        for (Pair<String, String> rename : renames) {
            SequentialFile fileTmp = fileFactory.createSequentialFile(rename.getA());
            SequentialFile fileTo = fileFactory.createSequentialFile(rename.getB());
            // delete a valid file depending on where the crash occurred during the control file delete
            if (fileTmp.exists()) {
                fileTo.delete();
                fileTmp.renameTo(rename.getB());
            }
        }
        controlFile.delete();
    }
    cleanupTmpFiles(".cmp");
    cleanupTmpFiles(".tmp");
    return;
}

28. AbstractJournalUpdateTask#writeControlFile()

Project: activemq-artemis
File: AbstractJournalUpdateTask.java
// Public --------------------------------------------------------
public static SequentialFile writeControlFile(final SequentialFileFactory fileFactory, final List<JournalFile> files, final List<JournalFile> newFiles, final List<Pair<String, String>> renames) throws Exception {
    SequentialFile controlFile = fileFactory.createSequentialFile(AbstractJournalUpdateTask.FILE_COMPACT_CONTROL);
    try {
        controlFile.open(1, false);
        JournalImpl.initFileHeader(fileFactory, controlFile, 0, 0);
        ActiveMQBuffer filesToRename = ActiveMQBuffers.dynamicBuffer(1);
        if (files == null) {
            filesToRename.writeInt(0);
        } else {
            filesToRename.writeInt(files.size());
            for (JournalFile file : files) {
                filesToRename.writeUTF(file.getFile().getFileName());
            }
        }
        if (newFiles == null) {
            filesToRename.writeInt(0);
        } else {
            filesToRename.writeInt(newFiles.size());
            for (JournalFile file : newFiles) {
                filesToRename.writeUTF(file.getFile().getFileName());
            }
        }
        // Renames from clean up third
        if (renames == null) {
            filesToRename.writeInt(0);
        } else {
            filesToRename.writeInt(renames.size());
            for (Pair<String, String> rename : renames) {
                filesToRename.writeUTF(rename.getA());
                filesToRename.writeUTF(rename.getB());
            }
        }
        JournalInternalRecord controlRecord = new JournalAddRecord(true, 1, (byte) 0, new ByteArrayEncoding(filesToRename.toByteBuffer().array()));
        ActiveMQBuffer renameBuffer = ActiveMQBuffers.dynamicBuffer(filesToRename.writerIndex());
        controlRecord.setFileID(0);
        controlRecord.encode(renameBuffer);
        ByteBuffer writeBuffer = fileFactory.newBuffer(renameBuffer.writerIndex());
        writeBuffer.put(renameBuffer.toByteBuffer().array(), 0, renameBuffer.writerIndex());
        writeBuffer.rewind();
        controlFile.writeDirect(writeBuffer, true);
        return controlFile;
    } finally {
        controlFile.close();
    }
}

29. SyncCalculation#syncTest()

Project: activemq-artemis
File: SyncCalculation.java
/**
    * It will perform a write test of blockSize * bocks, sinc on each write, for N tries.
    * It will return the lowest spent time from the tries.
    */
public static long syncTest(File datafolder, int blockSize, int blocks, int tries, boolean verbose, boolean aio) throws Exception {
    SequentialFileFactory factory = newFactory(datafolder, aio);
    SequentialFile file = factory.createSequentialFile("test.tmp");
    try {
        file.delete();
        file.open();
        file.fill(blockSize * blocks);
        long[] result = new long[tries];
        byte[] block = new byte[blockSize];
        for (int i = 0; i < block.length; i++) {
            block[i] = (byte) 't';
        }
        ByteBuffer bufferBlock = factory.newBuffer(blockSize);
        bufferBlock.put(block);
        bufferBlock.position(0);
        final ReusableLatch latch = new ReusableLatch(0);
        IOCallback callback = new IOCallback() {

            @Override
            public void done() {
                latch.countDown();
            }

            @Override
            public void onError(int errorCode, String errorMessage) {
            }
        };
        DecimalFormat dcformat = new DecimalFormat("###.##");
        for (int ntry = 0; ntry < tries; ntry++) {
            if (verbose) {
                System.out.println("**************************************************");
                System.out.println(ntry + " of " + tries + " calculation");
            }
            file.position(0);
            long start = System.currentTimeMillis();
            for (int i = 0; i < blocks; i++) {
                bufferBlock.position(0);
                latch.countUp();
                file.writeDirect(bufferBlock, true, callback);
                if (!latch.await(5, TimeUnit.SECONDS)) {
                    throw new IOException("Callback wasn't called");
                }
            }
            long end = System.currentTimeMillis();
            result[ntry] = (end - start);
            if (verbose) {
                double writesPerMillisecond = (double) blocks / (double) result[ntry];
                System.out.println("Time = " + result[ntry]);
                System.out.println("Writes / millisecond = " + dcformat.format(writesPerMillisecond));
                System.out.println("bufferTimeout = " + toNanos(result[ntry], blocks));
                System.out.println("**************************************************");
            }
        }
        factory.releaseDirectBuffer(bufferBlock);
        long totalTime = Long.MAX_VALUE;
        for (int i = 0; i < tries; i++) {
            if (result[i] < totalTime) {
                totalTime = result[i];
            }
        }
        return totalTime;
    } finally {
        try {
            file.close();
        } catch (Exception e) {
        }
        try {
            file.delete();
        } catch (Exception e) {
        }
        try {
            factory.stop();
        } catch (Exception e) {
        }
    }
}