Examples of nexj.core.rpc.ra.tx.PersistentJournal

nexj.core.rpc.ra.tx.PersistentJournal
A disk-based transactional journal. There can only be one instance reading/writing a journal file in a given process: this guaranteed by using the static factory method makeJournal. The journal cannot be shared by more than one process.

    * 2) Tests that transactions can be retrieved from the journal.
    */
   public void testRecover() throws Exception
   {
      File tempDirectory = TempFileUtil.makeTemporaryDirectory(getClass().getName() + "." + getName());
      PersistentJournal perJournal = PersistentJournal.makeJournal(tempDirectory);
      
      //A record that needs to be recovered. (XID1)
      Xid xid1 = makeXid(1);
      MemoryJournal journal1 = perJournal.getJournal(xid1);
      
      journal1.addRecord(new JournalRecordTesting(xid1, FileJournalRecordCopyInsert.OPCODE));
      journal1.addRecord(new JournalRecordTesting(xid1, JournalRecordPrepared.OPCODE));
      journal1.flush();
      journal1.completed();
      journal1 = null;
      
      
      //Completed record (XID2) interleaved with record needing recovery (XID3)
      Xid xid2 = makeXid(2);
      Xid xid3 = makeXid(3);
      MemoryJournal journal2a = perJournal.getJournal(xid2);
      MemoryJournal journal2b = perJournal.getJournal(xid3);
      
      journal2a.addRecord(new JournalRecordTesting(xid2, FileJournalRecordCopyUpdate.OPCODE));
      journal2a.flush();
      journal2b.addRecord(new JournalRecordTesting(xid3, FileJournalRecordCopyUpdate.OPCODE));
      journal2b.flush();
      journal2a.addRecord(new JournalRecordTesting(xid2, JournalRecordPrepared.OPCODE));
      journal2a.flush();
      journal2b.addRecord(new JournalRecordTesting(xid3, JournalRecordPrepared.OPCODE));
      journal2b.flush();
      journal2a.addRecord(new JournalRecordTesting(xid2, JournalRecordCompleted.OPCODE));
      journal2a.flush();
      journal2a.completed();
      journal2b.completed();
      journal2a = null;
      journal2b = null;
      
      
      //Repeated instructions; completed (XID4)
      Xid xid4 = makeXid(4);
      MemoryJournal journal3 = perJournal.getJournal(xid4);
      
      journal3.addRecord(new JournalRecordTesting(xid4, FileJournalRecordDelete.OPCODE));
      journal3.addRecord(new JournalRecordTesting(xid4, JournalRecordPrepared.OPCODE));
      journal3.addRecord(new JournalRecordTesting(xid4, JournalRecordPrepared.OPCODE));
      journal3.addRecord(new JournalRecordTesting(xid4, JournalRecordCompleted.OPCODE));
      journal3.addRecord(new JournalRecordTesting(xid4, JournalRecordPrepared.OPCODE));
      journal3.addRecord(new JournalRecordTesting(xid4, JournalRecordCompleted.OPCODE));
      journal3.flush();
      journal3.completed();
      journal3 = null;
      
      
      //Extraneous instructions; un-prepared (XID5), completed (XID6)
      Xid xid5 = makeXid(5);
      Xid xid6 = makeXid(6);
      MemoryJournal journal4a = perJournal.getJournal(xid5);
      MemoryJournal journal4b = perJournal.getJournal(xid6);
      
      journal4a.addRecord(new JournalRecordTesting(xid5, FileJournalRecordCopyInsert.OPCODE));
      journal4a.flush();
      journal4b.addRecord(new JournalRecordTesting(xid6, FileJournalRecordIncomingMove.OPCODE));
      journal4b.flush();
      journal4a.addRecord(new JournalRecordTesting(xid5, FileJournalRecordCopyUpdate.OPCODE));
      journal4a.flush();
      journal4b.addRecord(new JournalRecordTesting(xid6, JournalRecordPrepared.OPCODE));
      journal4b.flush();
      journal4a.addRecord(new JournalRecordTesting(xid5, FileJournalRecordDelete.OPCODE));
      journal4a.flush();
      journal4b.addRecord(new JournalRecordTesting(xid6, JournalRecordCompleted.OPCODE));
      journal4b.flush();
      journal4a.completed();
      journal4b.completed();
      journal4a = null;
      journal4b = null;
      
      
      //Just a PREPARED record by itself; recover (XID7)
      Xid xid7 = makeXid(7);
      MemoryJournal journal5 = perJournal.getJournal(xid7);
      
      journal5.addRecord(new JournalRecordTesting(xid7, JournalRecordPrepared.OPCODE));
      journal5.flush();
      journal5.completed();
      journal5 = null;
      
      
      //Just PREPARED and COMPLETED; completed (XID8)
      Xid xid8 = makeXid(8);
      MemoryJournal journal6 = perJournal.getJournal(xid8);
      
      journal6.addRecord(new JournalRecordTesting(xid8, JournalRecordPrepared.OPCODE));
      journal6.addRecord(new JournalRecordTesting(xid8, JournalRecordCompleted.OPCODE));
      journal6.flush();
      journal6.completed();
      journal6 = null;
      
      
      //Just COMPLETED; completed (XID9)
      Xid xid9 = makeXid(9);
      MemoryJournal journal7 = perJournal.getJournal(xid9);
      
      journal7.addRecord(new JournalRecordTesting(xid9, JournalRecordCompleted.OPCODE));
      journal7.flush();
      journal7.completed();
      journal7 = null;
      
      
      
      /* ********** CRASH ********** */
      PersistentJournal.closeAll();
      perJournal = null;
      
      
      
      //Recovery
      PersistentJournal recoverJournal = PersistentJournal.makeJournal(tempDirectory);
      Xid[] recoveredXids = recoverJournal.recover();
      
      assertEquals(3, recoveredXids.length);
      Arrays.sort(recoveredXids);
      assertEquals(makeXid(1), recoveredXids[0]);
      assertEquals(makeXid(3), recoveredXids[1]);
      assertEquals(makeXid(7), recoveredXids[2]);
      
      
      //Test getting some operations
      MemoryJournal recovered = recoverJournal.recoverJournal(makeXid(1));
      List recoveredOps = recovered.getRecords();
      
      //A record that needs to be recovered. (XID1)
      assertEquals(2, recoveredOps.size());
      assertEquals(new JournalRecordTesting(makeXid(1), FileJournalRecordCopyInsert.OPCODE), recoveredOps.get(0));
      assertEquals(new JournalRecordTesting(makeXid(1), JournalRecordPrepared.OPCODE), recoveredOps.get(1));
      recovered.forget(makeXid(1));
      
      //Completed record (XID2) interleaved with record needing recovery (XID3)
      recovered = recoverJournal.recoverJournal(makeXid(3));
      recoveredOps = recovered.getRecords();
      assertEquals(2, recoveredOps.size());
      assertEquals(new JournalRecordTesting(makeXid(3), FileJournalRecordCopyUpdate.OPCODE), recoveredOps.get(0));
      assertEquals(new JournalRecordTesting(makeXid(3), JournalRecordPrepared.OPCODE), recoveredOps.get(1));
      recovered.forget(makeXid(3));
      
      recoverJournal.close();
   }

View Full Code Here




   public void testJournalCompaction() throws Exception
   {
      File tempDirectory = TempFileUtil.makeTemporaryDirectory(getClass().getName() + "." + getName());
      PersistentJournal perJournal = PersistentJournal.makeJournal(tempDirectory);
      MemoryJournal j1, j2, j3;
      File tempFile1 = new File(tempDirectory, "journal1.bin");
      File tempFile2 = new File(tempDirectory, "journal2.bin");
      final int nHeaderLength = 2;
      final int nZeroObjectsLength = 7;


      assertEquals(nZeroObjectsLength, tempFile1.length());
      assertEquals(nHeaderLength, tempFile2.length());
      perJournal.setCompactionThreshold(nZeroObjectsLength);
      
      //Just one journal handle: should compact quickly!
      j1 = perJournal.getJournal(makeXid(1));  //NO COMPACT
      assertEquals(1, perJournal.getActiveTransactions());
      assertEquals(tempFile1, perJournal.getActiveJournal());
      j1.addRecord(new JournalRecordTesting(makeXid(1), FileJournalRecordCopyInsert.OPCODE));
      j1.addRecord(new JournalRecordTesting(makeXid(1), JournalRecordPrepared.OPCODE));
      j1.addRecord(new JournalRecordTesting(makeXid(1), JournalRecordCompleted.OPCODE));
      assertEquals(nZeroObjectsLength, tempFile1.length());
      j1.flush();
      assertTrue(tempFile1.length() > nZeroObjectsLength);
      j1.completed();  //COMPACT
      assertEquals(0, perJournal.getActiveTransactions());
      assertEquals(tempFile2, perJournal.getActiveJournal());
      assertEquals(nZeroObjectsLength, tempFile2.length());
      assertEquals(nHeaderLength, tempFile1.length());
      j1 = null;
      
      
      //Test handles overlapping in time:
      //---j1---COMPACT!
      //     ---j2---COMPACT!
      //          ---j3--->COMPACT!
      j1 = perJournal.getJournal(makeXid(2));  //NO COMPACT
      assertEquals(1, perJournal.getActiveTransactions());
      assertEquals(tempFile2, perJournal.getActiveJournal());
      j1.addRecord(new JournalRecordTesting(makeXid(2), FileJournalRecordCopyInsert.OPCODE));
      j1.flush();
      assertEquals(tempFile2, perJournal.getActiveJournal());
      assertTrue(tempFile2.length() > nZeroObjectsLength);
      assertEquals(nHeaderLength, tempFile1.length());
      
      j2 = perJournal.getJournal(makeXid(3));  //COMPACT
      assertEquals(tempFile1, perJournal.getActiveJournal());
      assertTrue(tempFile1.length() > nZeroObjectsLength);  //first record still active!
      assertEquals(nHeaderLength, tempFile2.length());
      j2.addRecord(new JournalRecordTesting(makeXid(3), FileJournalRecordDelete.OPCODE));
      j2.flush();
      j1.completed();  //COMPACT
      assertEquals(tempFile2, perJournal.getActiveJournal());
      assertEquals(nHeaderLength, tempFile1.length());
      assertTrue(tempFile2.length() > nZeroObjectsLength);  //second record still active!
      j1 = null;
      
      j3 = perJournal.getJournal(makeXid(4));  //COMPACT
      assertEquals(tempFile1, perJournal.getActiveJournal());
      assertEquals(nHeaderLength, tempFile2.length());
      assertTrue(tempFile1.length() > nZeroObjectsLength);  //second record still active!
      j2.completed();  //COMPACT
      assertEquals(tempFile2, perJournal.getActiveJournal());
      assertEquals(nHeaderLength, tempFile1.length());
      assertEquals(nZeroObjectsLength, tempFile2.length());  //third record still active, but is null!
      j2 = null;
      j3.completed();  //NO COMPACT
      assertEquals(tempFile2, perJournal.getActiveJournal());
      assertEquals(nHeaderLength, tempFile1.length());
      assertEquals(nZeroObjectsLength, tempFile2.length());
      j3 = null;
      
      
      //Test no compaction until crash recovered
      //---j1--- CRASH
      //               RESTART ---j2---
      //                                forget(j1) COMPACT
      j1 = perJournal.getJournal(makeXid(5));  //NO COMPACT
      assertEquals(tempFile2, perJournal.getActiveJournal());
      assertEquals(nHeaderLength, tempFile1.length());
      assertEquals(nZeroObjectsLength, tempFile2.length());
      
      j1.addRecord(new JournalRecordTesting(makeXid(5), FileJournalRecordCopyInsert.OPCODE));
      j1.addRecord(new JournalRecordTesting(makeXid(5), JournalRecordPrepared.OPCODE));
      j1.flush();
      assertTrue(tempFile2.length() > nZeroObjectsLength);


      //CRASH
      PersistentJournal.closeAll();
      j1 = null;
      perJournal = null;
      
      perJournal = PersistentJournal.makeJournal(tempDirectory);
      perJournal.setCompactionThreshold(nZeroObjectsLength);
      assertEquals(tempFile1, perJournal.getActiveJournal());
      assertEquals(nHeaderLength, tempFile2.length());
      assertTrue(tempFile1.length() > nZeroObjectsLength);
      
      j2 = perJournal.getJournal(makeXid(6));  //COMPACT
      assertEquals(tempFile2, perJournal.getActiveJournal());
      assertEquals(nHeaderLength, tempFile1.length());
      assertTrue(tempFile2.length() > nZeroObjectsLength);
      j2.addRecord(new JournalRecordTesting(makeXid(6), FileJournalRecordCopyUpdate.OPCODE));
      j2.addRecord(new JournalRecordTesting(makeXid(6), JournalRecordPrepared.OPCODE));
      j2.addRecord(new JournalRecordTesting(makeXid(6), JournalRecordCompleted.OPCODE));
      j2.flush();
      assertEquals(tempFile2, perJournal.getActiveJournal());
      j2.completed();  //COMPACT
      assertEquals(tempFile1, perJournal.getActiveJournal());
      assertEquals(nHeaderLength, tempFile2.length());
      assertTrue(tempFile1.length() > nZeroObjectsLength);
      j2 = null;
      
      j1 = perJournal.recoverJournal(makeXid(5));
      assertNotNull(j1);
      
      List opsList = j1.getRecords();
      
      assertEquals(2, opsList.size());
      assertEquals(new JournalRecordTesting(makeXid(5), FileJournalRecordCopyInsert.OPCODE), opsList.get(0));
      assertEquals(new JournalRecordTesting(makeXid(5), JournalRecordPrepared.OPCODE), opsList.get(1));
      
      //FORGET
      assertEquals(tempFile1, perJournal.getActiveJournal());
      j1.addRecord(new JournalRecordTesting(makeXid(5), JournalRecordCompleted.OPCODE));
      j1.flush();
      assertEquals(tempFile1, perJournal.getActiveJournal());
      j1.forget(makeXid(5));  //COMPACT
      assertEquals(tempFile2, perJournal.getActiveJournal());
      assertEquals(nHeaderLength, tempFile1.length());
      assertEquals(nZeroObjectsLength, tempFile2.length());
      j1 = null;
      
      perJournal.close();
   }

View Full Code Here

      
      //Make temporary output file
      this.writeData(new File(m_outgoingTempDirectory, "outgoing.txt"), data);
      
      //Make appropriate journal entry. (File, STATUS_READY)
      PersistentJournal pJournal = PersistentJournal.makeJournal(m_outgoingJournal);
      MemoryJournal journal = pJournal.getJournal(makeXid(7));
      
      journal.addRecord(new FileJournalRecordCopyInsert(makeXid(7),
         new File(m_outgoingTempDirectory, "outgoing.txt").getAbsolutePath(),
         new File(m_outgoingDirectory, "outgoing.txt").getAbsolutePath(),
         null, null));
      
      journal.addRecord(new FileJournalRecordMkTemp(makeXid(7),
         new File(m_outgoingTempDirectory, "outgoing.txt").getAbsolutePath(),
         null));
      
      journal.addRecord(new JournalRecordPrepared(makeXid(7)));
      
      journal.flush();
      
      
      //********** PROCESS CRASH RECOVERY **********
      PersistentJournal.closeAll();
      
      //Recover.
      ConnectionObjects outgoing2 = createOutgoingConnection();
      XAResource xar2 = outgoing2.getXAR();


      Xid[] xidArray = xar2.recover(XAResource.TMSTARTRSCAN);
      
      assertNotNull(xidArray);
      assertEquals(1, xidArray.length);
      assertNull(xar2.recover(XAResource.TMNOFLAGS));
      assertNull(xar2.recover(XAResource.TMENDRSCAN));
      
      Xid recoveredXid = xidArray[0];
      
      assertTrue(recoveredXid.equals(makeXid(7)));
      
      //Do the COMMIT.
      xar2.commit(recoveredXid, false);
      
      
      //Test that the file got written after all
      verifyData(new File(m_outgoingDirectory, "outgoing.txt"), data);
      
      FileOutputStream lockStream = new FileOutputStream(new File(m_outgoingDirectory, "outgoing.txt"));
      FileLock flock = lockStream.getChannel().tryLock(0L, Long.MAX_VALUE, false);
      
      assertTrue(flock.isValid());
      flock.release();
      
      
      //Temp directory should be empty
      assertEquals(0, m_outgoingTempDirectory.listFiles().length);
      
      //Journal must mark transaction as completed.
      pJournal = PersistentJournal.makeJournal(m_outgoingJournal);
      journal = pJournal.recoverJournal(makeXid(7));
      
      List recordsList = journal.getRecords();
      GenericJournalRecord lastRecord = (GenericJournalRecord)recordsList.get(recordsList.size() - 1);
      
      assertEquals(JournalRecordCompleted.OPCODE, lastRecord.getOpCode());
      assertEquals(recoveredXid, lastRecord.getXid());
      
      pJournal.close();
   }

View Full Code Here

TOP

Related Classes of nexj.core.rpc.ra.tx.PersistentJournal

nexj.core.rpc.file.ra.AppendingJournalTest

nexj.core.rpc.file.ra.FileXAResourceTest

nexj.core.rpc.file.ra.LockableFile

nexj.core.util.Binary

nexj.core.util.HashHolder

nexj.core.util.Holder

java.io.InputStream

java.util.NoSuchElementException

java.util.List

java.util.ArrayList

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.