Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one or more contributor license * agreements. See the NOTICE file distributed with this work for additional information regarding * copyright ownership. The ASF licenses this file to You under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance with the License. You may obtain a * copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software distributed under the License * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express * or implied. See the License for the specific language governing permissions and limitations under * the License. */ package org.apache.geode.internal.cache; import static org.junit.Assert.*; import java.io.File; import java.io.FileInputStream; import java.io.IOException; import java.nio.ByteBuffer; import java.util.ArrayList; import java.util.Arrays; import java.util.HashSet; import java.util.List; import java.util.Random; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicBoolean; import java.util.stream.IntStream; import com.jayway.awaitility.Awaitility; import org.apache.commons.io.FileUtils; import org.junit.Assert; import org.junit.Ignore; import org.junit.Test; import org.junit.experimental.categories.Category; import org.apache.geode.StatisticsFactory; import org.apache.geode.cache.AttributesFactory; import org.apache.geode.cache.CacheWriterException; import org.apache.geode.cache.CommitConflictException; import org.apache.geode.cache.DataPolicy; import org.apache.geode.cache.DiskAccessException; import org.apache.geode.cache.DiskStore; import org.apache.geode.cache.DiskStoreFactory; import org.apache.geode.cache.EntryEvent; import org.apache.geode.cache.EntryNotFoundException; import org.apache.geode.cache.Scope; import org.apache.geode.cache.util.CacheWriterAdapter; import org.apache.geode.internal.InternalDataSerializer; import org.apache.geode.internal.cache.Oplog.OPLOG_TYPE; import org.apache.geode.test.dunit.ThreadUtils; import org.apache.geode.test.dunit.Wait; import org.apache.geode.test.dunit.WaitCriterion; import org.apache.geode.test.junit.categories.FlakyTest; import org.apache.geode.test.junit.categories.IntegrationTest; /** * Testing Oplog API's */ @Category(IntegrationTest.class) public class OplogJUnitTest extends DiskRegionTestingBase { boolean proceed = false; private final DiskRegionProperties diskProps = new DiskRegionProperties(); static final int OP_CREATE = 1; static final int OP_MODIFY = 2; static final int OP_DEL = 3; protected volatile static Random random = new Random(); protected long expectedOplogSize = Oplog.OPLOG_NEW_ENTRY_BASE_REC_SIZE; volatile int totalSuccessfulOperations = 0; protected int numCreate = 0; protected int numModify = 0; protected int numDel = 0; protected long delta; protected boolean flushOccuredAtleastOnce = false; volatile protected boolean assertDone = false; boolean failure = false; /** The key for entry */ static final String KEY = "KEY1"; /** The initial value for key */ static final String OLD_VALUE = "VAL1"; /** The updated value for key */ static final String NEW_VALUE = "VAL2"; /** The value read from cache using LocalRegion.getValueOnDiskOrBuffer API */ static volatile String valueRead = null; /** Boolean to indicate test to proceed for validation */ static volatile boolean proceedForValidation = false; protected volatile Thread rollerThread = null; @Override protected final void postSetUp() throws Exception { diskProps.setDiskDirs(dirs); DiskStoreImpl.SET_IGNORE_PREALLOCATE = true; } @Override protected final void postTearDown() throws Exception { DiskStoreImpl.SET_IGNORE_PREALLOCATE = false; } /** * Test method for 'org.apache.geode.internal.cache.Oplog.isBackup()' */ @Test public void testIsBackup() { region = DiskRegionHelperFactory.getSyncOverFlowAndPersistRegion(cache, diskProps); if (!((LocalRegion) region).getDiskRegion().isBackup()) { fail("Test persist backup not being correctly set for overflow and persist"); } closeDown(); region = DiskRegionHelperFactory.getSyncOverFlowOnlyRegion(cache, diskProps); if (((LocalRegion) region).getDiskRegion().isBackup()) { fail("Test persist backup not being correctly set for overflow only mode"); } closeDown(); region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL); if (!((LocalRegion) region).getDiskRegion().isBackup()) { fail("Test persist backup not being correctly set for persist only"); } closeDown(); } /* * Test method for 'org.apache.geode.internal.cache.Oplog.useSyncWrites()' */ @Test public void testUseSyncWrites() { boolean result; diskProps.setSynchronous(true); region = DiskRegionHelperFactory.getSyncOverFlowAndPersistRegion(cache, diskProps); result = ((LocalRegion) region).getAttributes().isDiskSynchronous(); if (!result) { fail("Synchronous is false when it is supposed to be true"); } closeDown(); region = DiskRegionHelperFactory.getSyncOverFlowOnlyRegion(cache, diskProps); result = ((LocalRegion) region).getAttributes().isDiskSynchronous(); if (!result) { fail("Synchronous is false when it is supposed to be true"); } closeDown(); region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL); result = ((LocalRegion) region).getAttributes().isDiskSynchronous(); if (!result) { fail("Synchronous is false when it is supposed to be true"); } closeDown(); diskProps.setSynchronous(false); region = DiskRegionHelperFactory.getAsyncOverFlowAndPersistRegion(cache, diskProps); result = ((LocalRegion) region).getAttributes().isDiskSynchronous(); if (result) { fail("Synchronous is true when it is supposed to be false"); } closeDown(); region = DiskRegionHelperFactory.getAsyncOverFlowOnlyRegion(cache, diskProps); result = ((LocalRegion) region).getAttributes().isDiskSynchronous(); if (result) { fail("Synchronous is true when it is supposed to be false"); } closeDown(); region = DiskRegionHelperFactory.getAsyncPersistOnlyRegion(cache, diskProps); result = ((LocalRegion) region).getAttributes().isDiskSynchronous(); if (result) { fail("Synchronous is true when it is supposed to be false"); } closeDown(); } // @todo port testBufferOperations /** * Asif: Tests the correct behaviour of attributes like byte-threshhold, asynch thread wait * time,etc. 'org.apache.geode.internal.cache.Oplog.bufferOperations()' */ // @Test // public void testBufferOperations() // { // boolean result; // diskProps.setBytesThreshold(0); // region = DiskRegionHelperFactory.getAsyncOverFlowAndPersistRegion(cache, // diskProps); // Oplog.WriterThread writer = ((LocalRegion)region).getDiskRegion() // .getChild().getAsynchWriter(); // long waitTime = writer.getAsynchThreadWaitTime(); // long buffSize = writer.getBufferSize(); // result = waitTime == writer.getDefaultAsynchThreadWaitTime() // && buffSize == 0; // assertTrue("buffer operations is true when it is supposed to be false", // result); // closeDown(); // region = DiskRegionHelperFactory.getAsyncOverFlowOnlyRegion(cache, // diskProps); // writer = ((LocalRegion)region).getDiskRegion().getChild().getAsynchWriter(); // waitTime = writer.getAsynchThreadWaitTime(); // buffSize = writer.getBufferSize(); // result = waitTime == writer.getDefaultAsynchThreadWaitTime() // && buffSize == 0; // assertTrue("buffer operations is true when it is supposed to be false", // result); // closeDown(); // region = DiskRegionHelperFactory // .getAsyncPersistOnlyRegion(cache, diskProps); // writer = ((LocalRegion)region).getDiskRegion().getChild().getAsynchWriter(); // waitTime = writer.getAsynchThreadWaitTime(); // buffSize = writer.getBufferSize(); // result = waitTime == writer.getDefaultAsynchThreadWaitTime() // && buffSize == 0; // assertTrue("buffer operations is true when it is supposed to be false", // result); // closeDown(); // diskProps.setBytesThreshold(100); // region = DiskRegionHelperFactory.getAsyncOverFlowAndPersistRegion(cache, // diskProps); // writer = ((LocalRegion)region).getDiskRegion().getChild().getAsynchWriter(); // waitTime = writer.getAsynchThreadWaitTime(); // buffSize = writer.getBufferSize(); // result = waitTime <= 0 && buffSize > 0; // assertTrue("bufferoperations is false when it is supposed to be true", // result); // closeDown(); // region = DiskRegionHelperFactory.getAsyncOverFlowOnlyRegion(cache, // diskProps); // writer = ((LocalRegion)region).getDiskRegion().getChild().getAsynchWriter(); // waitTime = writer.getAsynchThreadWaitTime(); // buffSize = writer.getBufferSize(); // result = waitTime <= 0 && buffSize > 0; // assertTrue("baufferoperations is false when it is supposed to be true", // result); // closeDown(); // region = DiskRegionHelperFactory // .getAsyncPersistOnlyRegion(cache, diskProps); // writer = ((LocalRegion)region).getDiskRegion().getChild().getAsynchWriter(); // waitTime = writer.getAsynchThreadWaitTime(); // buffSize = writer.getBufferSize(); // result = waitTime <= 0 && buffSize > 0; // assertTrue("baufferoperations is false when it is supposed to be true", // result); // closeDown(); // } /** * Test method for 'org.apache.geode.internal.cache.Oplog.clear(File)' */ @Test public void testClear() { region = DiskRegionHelperFactory.getSyncOverFlowAndPersistRegion(cache, diskProps); putTillOverFlow(region); region.clear(); region.close(); region = DiskRegionHelperFactory.getSyncOverFlowAndPersistRegion(cache, diskProps); assertTrue(" failed in get OverflowAndPersist ", region.get(new Integer(0)) == null); closeDown(); region = DiskRegionHelperFactory.getSyncOverFlowOnlyRegion(cache, diskProps); putTillOverFlow(region); region.clear(); region.close(); region = DiskRegionHelperFactory.getSyncOverFlowOnlyRegion(cache, diskProps); assertTrue(" failed in get OverflowOnly ", region.get(new Integer(0)) == null); closeDown(); region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL); put100Int(); region.clear(); region.close(); region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL); assertTrue(" failed in get PersistOnly ", region.get(new Integer(0)) == null); closeDown(); } /** * Test method for 'org.apache.geode.internal.cache.Oplog.close()' */ @Test public void testClose() { { deleteFiles(); region = DiskRegionHelperFactory.getSyncOverFlowAndPersistRegion(cache, diskProps); DiskRegion dr = ((LocalRegion) region).getDiskRegion(); Oplog oplog = dr.testHook_getChild(); long id = oplog.getOplogId(); oplog.close(); // lk should still exist since it locks DiskStore not just one oplog // checkIfContainsFile(".lk"); StatisticsFactory factory = region.getCache().getDistributedSystem(); Oplog newOplog = new Oplog(id, dr.getOplogSet(), new DirectoryHolder(factory, dirs[0], 1000, 0)); dr.getOplogSet().setChild(newOplog); closeDown(); } { deleteFiles(); region = DiskRegionHelperFactory.getSyncOverFlowOnlyRegion(cache, diskProps); DiskRegion dr = ((LocalRegion) region).getDiskRegion(); dr.testHookCloseAllOverflowOplogs(); // lk should still exist since it locks DiskStore not just one oplog // checkIfContainsFile(".lk"); checkIfContainsFile("OVERFLOW"); closeDown(); } { deleteFiles(); region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL); DiskRegion dr = ((LocalRegion) region).getDiskRegion(); Oplog oplog = dr.testHook_getChild(); long id = oplog.getOplogId(); oplog.close(); // lk should still exist since it locks DiskStore not just one oplog // checkIfContainsFile(".lk"); StatisticsFactory factory = region.getCache().getDistributedSystem(); Oplog newOplog = new Oplog(id, dr.getOplogSet(), new DirectoryHolder(factory, dirs[0], 1000, 2)); dr.setChild(newOplog); closeDown(); } } @Override protected void closeDown() { DiskRegion dr = null; if (region != null) { dr = ((LocalRegion) region).getDiskRegion(); } super.closeDown(); if (dr != null) { dr.getDiskStore().close(); ((LocalRegion) region).getGemFireCache().removeDiskStore(dr.getDiskStore()); } } void checkIfContainsFile(String fileExtension) { for (int i = 0; i < 4; i++) { File[] files = dirs[i].listFiles(); for (int j = 0; j < files.length; j++) { if (files[j].getAbsolutePath().endsWith(fileExtension)) { fail("file " + files[j] + " still exists after oplog.close()"); } } } } /** * Test method for 'org.apache.geode.internal.cache.Oplog.destroy()' */ @Test public void testDestroy() { region = DiskRegionHelperFactory.getSyncOverFlowAndPersistRegion(cache, diskProps); put100Int(); putTillOverFlow(region); try { region.destroy(new Integer(0)); } catch (EntryNotFoundException e1) { logWriter.error("Exception occured", e1); fail(" Entry not found when it was expected to be there"); } region.close(); region = DiskRegionHelperFactory.getSyncOverFlowAndPersistRegion(cache, diskProps); assertTrue(" failed in get OverflowAndPersist ", region.get(new Integer(0)) == null); closeDown(); region = DiskRegionHelperFactory.getSyncOverFlowOnlyRegion(cache, diskProps); put100Int(); putTillOverFlow(region); try { region.destroy(new Integer(0)); } catch (EntryNotFoundException e1) { logWriter.error("Exception occured", e1); fail(" Entry not found when it was expected to be there"); } region.close(); region = DiskRegionHelperFactory.getSyncOverFlowOnlyRegion(cache, diskProps); assertTrue(" failed in get OverflowOnly ", region.get(new Integer(0)) == null); closeDown(); region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL); put100Int(); try { region.destroy(new Integer(0)); } catch (EntryNotFoundException e1) { logWriter.error("Exception occured", e1); fail(" Entry not found when it was expected to be there"); } region.close(); region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL); assertTrue(" failed in get PersistOnly ", region.get(new Integer(0)) == null); closeDown(); } /** * Test method for 'org.apache.geode.internal.cache.Oplog.remove(long)' */ @Test public void testRemove() { region = DiskRegionHelperFactory.getSyncOverFlowAndPersistRegion(cache, diskProps); putTillOverFlow(region); region.remove(new Integer(0)); region.close(); region = DiskRegionHelperFactory.getSyncOverFlowAndPersistRegion(cache, diskProps); assertTrue(" failed in get OverflowAndPersist ", region.get(new Integer(0)) == null); closeDown(); region = DiskRegionHelperFactory.getSyncOverFlowOnlyRegion(cache, diskProps); putTillOverFlow(region); region.remove(new Integer(0)); assertTrue(" failed in get OverflowOnly ", region.get(new Integer(0)) == null); region.close(); region = DiskRegionHelperFactory.getSyncOverFlowOnlyRegion(cache, diskProps); closeDown(); region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL); put100Int(); region.remove(new Integer(0)); assertTrue(" failed in get PersistOnly ", region.get(new Integer(0)) == null); region.close(); region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL); closeDown(); } // @todo: port testByteBufferCreationForCreateModifyAndDeleteOperation /** * This tests the final ByteBuffer object that gets created for synch/Asynch operation for a * create / modify & Delete operation * */ // @Test // public void testByteBufferCreationForCreateModifyAndDeleteOperation() // { // // Asif First create a persist only disk region which is of aysnch // // & switch of OplOg type // diskProps.setMaxOplogSize(1000); // diskProps.setBytesThreshold(500); // diskProps.setPersistBackup(true); // diskProps.setRolling(false); // diskProps.setSynchronous(false); // diskProps.setTimeInterval(-1); // diskProps.setOverflow(false); // region = DiskRegionHelperFactory // .getAsyncPersistOnlyRegion(cache, diskProps); // byte[] val = new byte[10]; // for (int i = 0; i < 10; ++i) { // val[i] = (byte)i; // } // region.put(new Integer(1), val); // DiskEntry entry = ((DiskEntry)((LocalRegion)region) // .basicGetEntry(new Integer(1))); // long opKey = entry.getDiskId().getKeyId(); // // The final position in the Byte Buffer created in Asynch Op should be // int createPos = 2 + 4 + val.length; // if (opKey > Integer.MAX_VALUE) { // createPos += 8; // } // else if (opKey > Short.MAX_VALUE) { // createPos += 4; // } // else { // createPos += 2; // } // createPos += 4; // createPos += EntryEventImpl.serialize(new Integer(1)).length; // DiskRegion dr = ((LocalRegion)region).getDiskRegion(); // Oplog.WriterThread writer = dr.getChild().getAsynchWriter(); // Oplog.AsyncOp asynchOp = writer // .getAsynchOpForEntryFromPendingFlushMap(entry.getDiskId()); // ByteBuffer bb = asynchOp.getByteBuffer(); // assertTrue(createPos == bb.position()); // assertTrue(bb.limit() == bb.capacity()); // byte val1[] = new byte[20]; // for (int i = 0; i < 20; ++i) { // val1[i] = (byte)i; // } // region.put(new Integer(1), val1); // bb = writer.getAsynchOpForEntryFromPendingFlushMap(entry.getDiskId()) // .getByteBuffer(); // createPos += 10; // assertTrue(createPos == bb.position()); // assertTrue(bb.limit() == bb.capacity()); // byte val2[] = new byte[30]; // for (int i = 0; i < 30; ++i) { // val2[i] = (byte)i; // } // region.put(new Integer(1), val2); // bb = writer.getAsynchOpForEntryFromPendingFlushMap(entry.getDiskId()) // .getByteBuffer(); // createPos += 10; // assertTrue(createPos == bb.position()); // assertTrue(bb.limit() == bb.capacity()); // long opSizeBeforeCreateRemove = dr.getChild().getOplogSize(); // long pendingFlushSize = dr.getChild().getAsynchWriter() // .getCurrentBufferedBytesSize(); // region.put(new Integer(2), val2); // DiskEntry entry2 = ((DiskEntry)((LocalRegion)region) // .basicGetEntry(new Integer(2))); // bb = writer.getAsynchOpForEntryFromPendingFlushMap(entry2.getDiskId()) // .getByteBuffer(); // assertNotNull(bb); // region.remove(new Integer(2)); // assertNull(writer // .getAsynchOpForEntryFromPendingFlushMap(entry2.getDiskId())); // assertIndexDetailsEquals(opSizeBeforeCreateRemove, dr.getChild().getOplogSize()); // assertIndexDetailsEquals(pendingFlushSize, dr.getChild().getAsynchWriter() // .getCurrentBufferedBytesSize()); // closeDown(); // } /** * Tests whether the data is written in the right format on the disk * */ @Test public void testFaultInOfValuesFromDisk() { try { // Asif First create a persist only disk region which is of aysnch // & switch of OplOg type diskProps.setMaxOplogSize(1000); diskProps.setPersistBackup(true); diskProps.setRolling(false); diskProps.setSynchronous(true); diskProps.setTimeInterval(-1); diskProps.setOverflow(false); region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL); byte[] val = new byte[10]; for (int i = 0; i < 10; ++i) { val[i] = (byte) i; } region.put(new Integer(1), val); DiskEntry entry = ((DiskEntry) ((LocalRegion) region).basicGetEntry(new Integer(1))); DiskRegion dr = ((LocalRegion) region).getDiskRegion(); val = (byte[]) dr.getNoBuffer(entry.getDiskId()); for (int i = 0; i < 10; ++i) { if (val[i] != (byte) i) { fail("Test for fault in from disk failed"); } } val = (byte[]) DiskStoreImpl .convertBytesAndBitsIntoObject(dr.getBytesAndBitsWithoutLock(entry.getDiskId(), true, false)); for (int i = 0; i < 10; ++i) { if (val[i] != (byte) i) { fail("Test for fault in from disk failed"); } } region.invalidate(new Integer(1)); assertTrue(dr.getNoBuffer(entry.getDiskId()) == Token.INVALID); } catch (Exception e) { logWriter.error("Exception occured", e); fail(e.toString()); } closeDown(); } // @todo port testAsynchWriterTerminationOnSwitch /** * Tests the termination of asynch writer for an Oplog after the switch has been made * */ // @Test // public void testAsynchWriterTerminationOnSwitch() // { // // & switch of OplOg type // diskProps.setMaxOplogSize(23); // diskProps.setBytesThreshold(0); // diskProps.setPersistBackup(true); // diskProps.setRolling(false); // diskProps.setSynchronous(false); // diskProps.setTimeInterval(10000); // diskProps.setOverflow(false); // // diskProps.setDiskDirs(new File[]{new File("test1"), new // // File("test2"), // // new File("test3")}); // region = DiskRegionHelperFactory // .getAsyncPersistOnlyRegion(cache, diskProps); // DiskRegion dr = ((LocalRegion)region).getDiskRegion(); // Oplog.WriterThread writer = dr.getChild().getAsynchWriter(); // // Populate data just below the switch over threshhold // byte[] val = new byte[5]; // for (int i = 0; i < 5; ++i) { // val[i] = (byte)i; // } // region.put(new Integer(1), val); // DiskEntry entry = ((DiskEntry)((LocalRegion)region) // .basicGetEntry(new Integer(1))); // long opKey = entry.getDiskId().getKeyId(); // // The final position in the Byte Buffer created in Asynch Op should be // int createPos = 2 + 4 + val.length; // if (opKey > Integer.MAX_VALUE) { // createPos += 8; // } // else if (opKey > Short.MAX_VALUE) { // createPos += 4; // } // else { // createPos += 2; // } // createPos += 4; // createPos += EntryEventImpl.serialize(new Integer(1)).length; // assertTrue(createPos == 22); // region.put(new Integer(2), val); // DistributedTestCase.join(writer.getThread(), 10 * 1000, null); // closeDown(); // } /** * Tests the original ByteBufferPool gets transferred to the new Oplog for synch mode * */ @Test public void testByteBufferPoolTransferForSynchMode() { diskProps.setMaxOplogSize(1024); diskProps.setBytesThreshold(0); diskProps.setPersistBackup(true); diskProps.setRolling(false); diskProps.setSynchronous(true); diskProps.setTimeInterval(10000); diskProps.setOverflow(false); // diskProps.setDiskDirs(new File[]{new File("test1"), new // File("test2"), // new File("test3")}); region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL); DiskRegion dr = ((LocalRegion) region).getDiskRegion(); // assertNull(dr.getChild().getAsynchWriter()); // Populate data just below the switch over threshhold byte[] val = new byte[5]; for (int i = 0; i < 5; ++i) { val[i] = (byte) i; } region.put(new Integer(1), val); ((LocalRegion) region).basicGetEntry(new Integer(1)); Oplog old = dr.testHook_getChild(); ByteBuffer oldWriteBuf = old.getWriteBuf(); region.forceRolling(); // start a new oplog region.put(new Integer(2), val); Oplog switched = dr.testHook_getChild(); assertTrue(old != switched); assertEquals(dr.getDiskStore().persistentOplogs.getChild(2), switched); assertEquals(oldWriteBuf, switched.getWriteBuf()); assertEquals(null, old.getWriteBuf()); closeDown(); } // @todo port this test if needed. ByteBufferPool code is going to change /** * Tests the ByteBufferPool usage during asynch mode operation & ensuring that GetOperation does * not get corrupted data due to returing of ByetBuffer to the pool. There are 5 pre created pools * in Oplog . Each pool has size of 1. Out of 5 pools , only one pool is used by the test. Thus * there are 4 bytebuffers which will always be free. Thus if the asynch writer had initially 8 * byte buffers only 4 will be released * */ // @Test // public void testByteBufferPoolUsageForAsynchMode() // { // final int PRCREATED_POOL_NUM = 5; // try { // // Asif First create a persist only disk region which is of aysnch // // & switch of OplOg type // diskProps.setMaxOplogSize(1000); // diskProps.setPersistBackup(true); // diskProps.setRolling(false); // diskProps.setSynchronous(false); // diskProps.setTimeInterval(-1); // diskProps.setOverflow(false); // final int byte_threshold = 500; // diskProps.setBytesThreshold(byte_threshold); // byte[] val = new byte[50]; // region = DiskRegionHelperFactory.getAsyncPersistOnlyRegion(cache, // diskProps); // for (int i = 0; i < 50; ++i) { // val[i] = (byte)i; // } // region.put(new Integer(1), val); // final int singleOpSize = evaluateSizeOfOperationForPersist( // new Integer(1), val, ((DiskEntry)((LocalRegion)region) // .basicGetEntry(new Integer(1))).getDiskId(), OP_CREATE); // final int loopCount = byte_threshold / singleOpSize + 1; // LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = true; // final Thread th = new Thread(new Runnable() { // public void run() // { // takeRecursiveLockOnAllEntries(1); // DiskRegion dr = ((LocalRegion)region).getDiskRegion(); // // Asif : Sleep for somemore time // try { // Thread.yield(); // Thread.sleep(4000); // } // catch (InterruptedException ie) { // logWriter.error("Exception occured", ie); // failureCause = "No guarantee of vaildity of result hence failing. Exception = " // + ie; // testFailed = true; // fail("No guarantee of vaildity of result hence failing. Exception = " // + ie); // } // // There shoudl beatleast one Pool which has active counts // // as two // Oplog.ByteBufferPool bbp = null; // List pools = dr.getChild().getByteBufferPoolList(); // Iterator itr = pools.iterator(); // boolean found = false; // while (itr.hasNext()) { // bbp = (Oplog.ByteBufferPool)itr.next(); // int len = bbp.getByteBufferHolderList().size(); // if (len == (loopCount - (PRCREATED_POOL_NUM - 1))) { // found = true; // break; // } // } // if (!found) { // testFailed = true; // failureCause = "Test failed as the Asynch writer did not release ByetBuffer after get // operation"; // fail("Test failed as the Asynch writer did not release ByetBuffer after get operation"); // } // } // private void takeRecursiveLockOnAllEntries(int key) // { // // Get the DisKID // DiskRegion dr = ((LocalRegion)region).getDiskRegion(); // if (key > loopCount) { // // Interrupt the writer thread so as to start releasing // // bytebuffer to pool // //dr.getChild().getAsynchWriter().interrupt(); // // Sleep for a while & check the active ByteBuffer // // count. // // It should be two // try { // Thread.yield(); // Thread.sleep(5000); // } // catch (InterruptedException ie) { // logWriter.error("Exception occured", ie); // failureCause = "No guarantee of vaildity of result hence failing. Exception = " // + ie; // testFailed = true; // fail("No guarantee of vaildity of result hence failing. Exception = " // + ie); // } // // Check the number of ByteBuffers in the pool. // List pools = dr.getChild().getByteBufferPoolList(); // // There shoudl beatleast one Pool which has active // // counts as two // Oplog.ByteBufferPool bbp = null; // Iterator itr = pools.iterator(); // boolean found = true; // int len = -1; // while (itr.hasNext()) { // bbp = (Oplog.ByteBufferPool)itr.next(); // len = bbp.getByteBufferHolderList().size(); // if (len > 1) { // found = false; // break; // } // } // if (!found) { // failureCause = "Test failed as the Asynch writer released ByteBuffer before get operation. The // length of byte buffer pool is found to be greater than 0. the length is" // + len; // testFailed = true; // fail("Test failed as the Asynch writer released ByteBuffer before get operation"); // } // } // else { // DiskEntry entry = ((DiskEntry)((LocalRegion)region) // .basicGetEntry(new Integer(key))); // DiskId id = entry.getDiskId(); // synchronized (id) { // takeRecursiveLockOnAllEntries(++key); // } // } // } // }); // CacheObserver old = CacheObserverHolder // .setInstance(new CacheObserverAdapter() { // public void afterWritingBytes() // { // // Asif Start a Thread & do a get in the thread without // // releasing the // // lock on dik ID // th.start(); // synchronized (OplogJUnitTest.this) { // OplogJUnitTest.this.proceed = true; // OplogJUnitTest.this.notify(); // } // try { // th.join(30 * 1000); // Yes, really use Thread#join here // fail("never interrupted"); // } // catch (InterruptedException ie) { // // OK. Expected the interrupted Exception // if (debug) // System.out.println("Got the right exception"); // } // } // }); // int totalOpSize = singleOpSize; // for (int j = 1; j < loopCount; ++j) { // region.put(new Integer(j + 1), val); // totalOpSize += evaluateSizeOfOperationForPersist(new Integer(j + 1), // val, ((DiskEntry)((LocalRegion)region).basicGetEntry(new Integer( // j + 1))).getDiskId(), OP_CREATE); // } // assertTrue(totalOpSize - byte_threshold <= singleOpSize); // if (!proceed) { // synchronized (this) { // if (!proceed) { // this.wait(25000); // if (!proceed) { // fail("Test failed as no callback recieved from asynch writer"); // } // } // } // } // DistributedTestCase.join(th, 30 * 1000, null); // CacheObserverHolder.setInstance(old); // } // catch (Exception e) { // logWriter.error("Exception occured", e); // fail(e.toString()); // } // assertFalse(failureCause, testFailed); // LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false; // closeDown(); // } // give the new oplog record format it is too hard for the test to calculate // the expected size // /** // */ // @Test // public void testSynchModeConcurrentOperations() // { // final Map map = new HashMap(); // diskProps.setMaxOplogSize(1024 * 1024 * 20); // diskProps.setPersistBackup(true); // diskProps.setRolling(false); // diskProps.setSynchronous(true); // diskProps.setOverflow(false); // final int THREAD_COUNT = 90; // final byte[] val = new byte[50]; // region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps); // for (int i = 1; i < 101; ++i) { // map.put(new Integer(i), new Integer(i)); // } // Thread[] threads = new Thread[THREAD_COUNT]; // for (int i = 0; i < THREAD_COUNT; ++i) { // threads[i] = new Thread(new Runnable() { // public void run() // { // int sizeOfOp = 0; // DiskId id = null; // for (int j = 0; j < 50; ++j) { // int keyNum = random.nextInt(10) + 1; // Integer key = new Integer(keyNum); // Integer intgr = (Integer)map.get(key); // try { // synchronized (intgr) { // region.create(key, val); // DiskEntry entry = ((DiskEntry)((LocalRegion)region) // .basicGetEntry(key)); // id = entry.getDiskId(); // } // sizeOfOp = OplogJUnitTest.evaluateSizeOfOperationForPersist(key, // val, id, OP_CREATE); // synchronized (OplogJUnitTest.this) { // OplogJUnitTest.this.expectedOplogSize += sizeOfOp; // ++OplogJUnitTest.this.totalSuccessfulOperations; // ++OplogJUnitTest.this.numCreate; // } // } // catch (EntryExistsException eee) { // if (OplogJUnitTest.this.logWriter.finerEnabled()) { // OplogJUnitTest.this.logWriter // .finer("The entry already exists so this operation will not increase the size of oplog"); // } // } // try { // boolean isUpdate = false; // synchronized (intgr) { // isUpdate = region.containsKey(key); // region.put(key, val); // DiskEntry entry = ((DiskEntry)((LocalRegion)region) // .basicGetEntry(key)); // id = entry.getDiskId(); // } // sizeOfOp = OplogJUnitTest.evaluateSizeOfOperationForPersist(key, // val, id, (isUpdate ? OP_MODIFY : OP_CREATE)); // synchronized (OplogJUnitTest.this) { // OplogJUnitTest.this.expectedOplogSize += sizeOfOp; // ++OplogJUnitTest.this.totalSuccessfulOperations; // if (!isUpdate) { // ++OplogJUnitTest.this.numCreate; // } // else { // ++OplogJUnitTest.this.numModify; // } // } // } // catch (EntryDestroyedException ede) { // if (OplogJUnitTest.this.logWriter.finerEnabled()) { // OplogJUnitTest.this.logWriter // .finer("The entry already exists so this operation will not increase the size of oplog"); // } // } // boolean deleted = false; // synchronized (intgr) { // if (region.containsKey(key)) { // DiskEntry entry = ((DiskEntry)((LocalRegion)region) // .basicGetEntry(key)); // id = entry.getDiskId(); // region.remove(key); // deleted = true; // } // } // if (deleted) { // sizeOfOp = OplogJUnitTest.evaluateSizeOfOperationForPersist(key, // null, id, OP_DEL); // synchronized (OplogJUnitTest.this) { // OplogJUnitTest.this.expectedOplogSize += sizeOfOp; // ++OplogJUnitTest.this.totalSuccessfulOperations; // ++OplogJUnitTest.this.numDel; // } // } // } // } // }); // threads[i].start(); // } // for (int i = 0; i < THREAD_COUNT; ++i) { // DistributedTestCase.join(threads[i], 30 * 1000, null); // } // long inMemOplogSize = 0; // File opFile = null; // try { // opFile = ((LocalRegion)region).getDiskRegion().getChild().getOplogFile(); // } // catch (Exception e) { // logWriter // .error( // "Exception in synching data present in the buffers of RandomAccessFile of Oplog, to the disk", // e); // fail("Test failed because synching of data present in buffer of RandomAccesFile "); // } // synchronized (opFile) { // inMemOplogSize = ((LocalRegion)region).getDiskRegion().getChild().getOplogSize(); // } // long actFileSize = 0; // try { // actFileSize = ((LocalRegion)region).getDiskRegion().getChild().testGetOplogFileLength(); // } // catch (IOException e) { // fail("exception not expected" + e); // fail("The test failed as the oplog could not eb synched to disk"); // } // assertIndexDetailsEquals((this.numCreate + this.numDel + this.numModify), // this.totalSuccessfulOperations); // assertTrue(" The expected oplog size =" + inMemOplogSize // + " Actual Oplog file size =" + actFileSize, // inMemOplogSize == actFileSize); // assertTrue(" The expected oplog size =" + this.expectedOplogSize // + " In memeory Oplog size =" + inMemOplogSize, // this.expectedOplogSize == inMemOplogSize); // closeDown(); // } static int evaluateSizeOfOperationForPersist(Object key, byte[] val, DiskId id, int OperationType) { int size = 1; long opKey = id.getKeyId(); switch (OperationType) { case OP_CREATE: size += 4 + EntryEventImpl.serialize(key).length + 1 + 4 + val.length; break; case OP_MODIFY: // @todo how do a know if the key needed to be serialized? size += 1 + 4 + val.length + Oplog.bytesNeeded(Oplog.abs(opKey)); break; case OP_DEL: size += Oplog.bytesNeeded(Oplog.abs(opKey)); break; } return size; } // give the new oplog record format it is too hard for the test to calculate // the expected size // /** // * Tests whether the switching of Oplog happens correctly without size // * violation in case of concurrent region operations for synch mode. // */ // @Test // public void testSwitchingForConcurrentSynchedOperations() // { // final Map map = new HashMap(); // final int MAX_OPLOG_SIZE = 500; // diskProps.setMaxOplogSize(MAX_OPLOG_SIZE); // diskProps.setPersistBackup(true); // diskProps.setRolling(false); // diskProps.setSynchronous(true); // diskProps.setOverflow(false); // final int THREAD_COUNT = 5; // final byte[] val = new byte[50]; // final byte[] uval = new byte[1]; // region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps); // for (int i = 1; i < 101; ++i) { // map.put(new Integer(i), new Integer(i)); // } // final AI uniqueCtr = CFactory.createAI(); // Thread[] threads = new Thread[THREAD_COUNT]; // for (int i = 0; i < THREAD_COUNT; ++i) { // threads[i] = new Thread(new Runnable() { // public void run() // { // int sizeOfOp = 0; // DiskId id = null; // for (int j = 0; j < 50; ++j) { // int keyNum = random.nextInt(10) + 1; // Integer key = new Integer(keyNum); // Integer intgr = (Integer)map.get(key); // try { // String uniqueKey = "UK" + uniqueCtr.incrementAndGet(); // // since the files for "empty" oplogs now get cleaned up early // // create a unique key to keep this oplog alive. // region.create(uniqueKey, uval); // DiskEntry uentry = ((DiskEntry)((LocalRegion)region) // .basicGetEntry(uniqueKey)); // sizeOfOp = OplogJUnitTest.evaluateSizeOfOperationForPersist(uniqueKey, uval, // uentry.getDiskId(), OP_CREATE); // synchronized (OplogJUnitTest.this) { // OplogJUnitTest.this.expectedOplogSize += sizeOfOp; // ++OplogJUnitTest.this.totalSuccessfulOperations; // ++OplogJUnitTest.this.numCreate; // } // synchronized (intgr) { // region.create(key, val); // DiskEntry entry = ((DiskEntry)((LocalRegion)region) // .basicGetEntry(key)); // id = entry.getDiskId(); // } // sizeOfOp = OplogJUnitTest.evaluateSizeOfOperationForPersist(key, // val, id, OP_CREATE); // synchronized (OplogJUnitTest.this) { // OplogJUnitTest.this.expectedOplogSize += sizeOfOp; // ++OplogJUnitTest.this.totalSuccessfulOperations; // ++OplogJUnitTest.this.numCreate; // } // } // catch (EntryExistsException eee) { // if (logWriter.finerEnabled()) { // logWriter // .finer("The entry already exists so this operation will not increase the size of oplog"); // } // } // try { // boolean isUpdate = false; // synchronized (intgr) { // isUpdate = region.containsKey(key) && region.get(key) != null // && region.get(key) != Token.DESTROYED; // region.put(key, val); // DiskEntry entry = ((DiskEntry)((LocalRegion)region) // .basicGetEntry(key)); // id = entry.getDiskId(); // } // sizeOfOp = OplogJUnitTest.evaluateSizeOfOperationForPersist(key, // val, id, (isUpdate ? OP_MODIFY : OP_CREATE)); // synchronized (OplogJUnitTest.this) { // OplogJUnitTest.this.expectedOplogSize += sizeOfOp; // ++OplogJUnitTest.this.totalSuccessfulOperations; // if (!isUpdate) { // ++OplogJUnitTest.this.numCreate; // } // else { // ++OplogJUnitTest.this.numModify; // } // } // } // catch (EntryDestroyedException ede) { // if (logWriter.finerEnabled()) { // logWriter // .finer("The entry already exists so this operation will not increase the size of oplog"); // } // } // boolean deleted = false; // synchronized (intgr) { // if (region.containsKey(key) && region.get(key) != null // && region.get(key) != Token.DESTROYED) { // DiskEntry entry = ((DiskEntry)((LocalRegion)region) // .basicGetEntry(key)); // id = entry.getDiskId(); // region.remove(key); // deleted = true; // } // } // if (deleted) { // sizeOfOp = OplogJUnitTest.evaluateSizeOfOperationForPersist(key, // null, id, OP_DEL); // synchronized (OplogJUnitTest.this) { // OplogJUnitTest.this.expectedOplogSize += sizeOfOp; // ++OplogJUnitTest.this.totalSuccessfulOperations; // ++OplogJUnitTest.this.numDel; // } // } // } // } // }); // threads[i].start(); // } // for (int i = 0; i < THREAD_COUNT; ++i) { // DistributedTestCase.join(threads[i], 30 * 1000, null); // } // long currentOplogID = ((LocalRegion)region).getDiskRegion().getChild() // .getOplogId(); // assertTrue( // " Switching did not happen, increase the iterations to insert more data ", // currentOplogID > 1); // long inMemOplogSize = 0; // for (int j = 1; j <= currentOplogID; ++j) { // Oplog oplog = ((LocalRegion)region).getDiskRegion().getChild(j); // // if (j < currentOplogID) { // // // oplogs are now closed to save memory and file descriptors // // // once they are no longer needed // // assertIndexDetailsEquals(null, oplog); // // } else { // inMemOplogSize += oplog.getOplogSize(); // logWriter.info(" Oplog size="+ oplog.getOplogSize() + " Max Oplog size // acceptable="+MAX_OPLOG_SIZE ); // assertTrue( // " The max Oplog Size limit is violated when taken the inmemory oplog size", // oplog.getOplogSize() <= MAX_OPLOG_SIZE); // // File opFile = null; // try { // oplog.getOplogFile(); // } // catch (Exception e) { // logWriter // .error( // "Exception in synching data present in the buffers of RandomAccessFile of Oplog, to the disk", // e); // fail("Test failed because synching of data present in buffer of RandomAccesFile "); // } // assertTrue( // " The max Oplog Size limit is violated when taken the actual file size", // oplog.getActualFileLength() <= MAX_OPLOG_SIZE); // assertIndexDetailsEquals(oplog.getOplogSize(), oplog.getActualFileLength()); // // } // } // inMemOplogSize += // ((LocalRegion)region).getDiskRegion().getDiskStore().undeletedOplogSize.get(); // assertTrue(" The sum of all oplogs size as expected =" // + this.expectedOplogSize + " Actual sizes of all oplogs =" // + inMemOplogSize, this.expectedOplogSize == inMemOplogSize); // assertIndexDetailsEquals((this.numCreate + this.numDel + this.numModify), // this.totalSuccessfulOperations); // closeDown(); // } // give the new oplog record format it is too hard for the test to calculate // the expected size // /** // * Tests whether the switching of Oplog happens correctly without size // * violation in case of concurrent region operations for asynch mode. // * // */ // @Test // public void testSwitchingForConcurrentASynchedOperations() // { // final int MAX_OPLOG_SIZE = 500; // diskProps.setMaxOplogSize(MAX_OPLOG_SIZE); // diskProps.setPersistBackup(true); // diskProps.setRolling(false); // diskProps.setSynchronous(false); // diskProps.setOverflow(false); // diskProps.setBytesThreshold(100); // final int THREAD_COUNT = 40; // final byte[] val = new byte[50]; // region = DiskRegionHelperFactory // .getAsyncPersistOnlyRegion(cache, diskProps); // Thread[] threads = new Thread[THREAD_COUNT]; // for (int i = 0; i < THREAD_COUNT; ++i) { // final int threadNum = (i + 1); // threads[i] = new Thread(new Runnable() { // public void run() // { // int sizeOfOp = 0; // DiskId id = null; // try { // region.create(new Integer(threadNum), val); // } // catch (EntryExistsException e) { // e.printStackTrace(); // testFailed = true; // failureCause = "Entry existed with key =" + threadNum; // fail("Entry existed with key =" + threadNum); // } // DiskEntry entry = ((DiskEntry)((LocalRegion)region) // .basicGetEntry(new Integer(threadNum))); // id = entry.getDiskId(); // sizeOfOp = OplogJUnitTest.evaluateSizeOfOperationForPersist( // new Integer(threadNum), val, id, OP_CREATE); // synchronized (OplogJUnitTest.this) { // OplogJUnitTest.this.expectedOplogSize += sizeOfOp; // ++OplogJUnitTest.this.totalSuccessfulOperations; // ++OplogJUnitTest.this.numCreate; // } // } // }); // threads[i].start(); // } // for (int i = 0; i < THREAD_COUNT; ++i) { // DistributedTestCase.join(threads[i], 30 * 1000, null); // } // long currentOplogID = ((LocalRegion)region).getDiskRegion().getChild() // .getOplogId(); // assertTrue( // " Switching did not happen, increase the iterations to insert more data ", // currentOplogID > 1); // if (debug) // System.out.print("Total number of oplogs created = " + currentOplogID); // long inMemOplogSize = 0; // for (int j = 1; j <= currentOplogID; ++j) { // Oplog oplog = ((LocalRegion)region).getDiskRegion().getChild(j); // // if (j < currentOplogID) { // // // oplogs are now closed to save memory and file descriptors // // // once they are no longer needed // // assertIndexDetailsEquals(null, oplog); // // } else { // inMemOplogSize += oplog.getOplogSize(); // //oplog.forceFlush(); // assertTrue( // " The max Oplog Size limit is violated when taken the inmemory oplog size", // oplog.getOplogSize() <= MAX_OPLOG_SIZE); // // File opFile = null; // try { // oplog.getOplogFile(); // } // catch (Exception e) { // logWriter // .error( // "Exception in synching data present in the buffers of RandomAccessFile of Oplog, to the disk", // e); // fail("Test failed because synching of data present in buffer of RandomAccesFile "); // } // assertTrue( // " The max Oplog Size limit is violated when taken the actual file size", // oplog.getActualFileLength() <= MAX_OPLOG_SIZE); // assertIndexDetailsEquals(oplog.getOplogSize(), oplog.getActualFileLength()); // // } // } // inMemOplogSize += // ((LocalRegion)region).getDiskRegion().getDiskStore().undeletedOplogSize.get(); // assertTrue(" The sum of all oplogs size as expected =" // + this.expectedOplogSize + " Actual sizes of all oplogs =" // + inMemOplogSize, this.expectedOplogSize == inMemOplogSize); // assertIndexDetailsEquals((this.numCreate + this.numDel + this.numModify), // this.totalSuccessfulOperations); // assertFalse(failureCause, testFailed); // closeDown(); // } // /** // */ // @Test // public void testAsyncWriterTerminationAfterSwitch() // { // final int MAX_OPLOG_SIZE = 500; // diskProps.setMaxOplogSize(MAX_OPLOG_SIZE); // diskProps.setPersistBackup(true); // diskProps.setRolling(false); // diskProps.setSynchronous(false); // diskProps.setOverflow(false); // diskProps.setBytesThreshold(100); // final int THREAD_COUNT = 40; // final byte[] val = new byte[50]; // region = DiskRegionHelperFactory // .getAsyncPersistOnlyRegion(cache, diskProps); // Thread[] threads = new Thread[THREAD_COUNT]; // for (int i = 0; i < THREAD_COUNT; ++i) { // final int threadNum = (i + 1); // threads[i] = new Thread(new Runnable() { // public void run() // { // int sizeOfOp = 0; // DiskId id = null; // try { // region.create(new Integer(threadNum), val); // } // catch (EntryExistsException e) { // testFailed = true; // failureCause = "Entry existed with key =" + threadNum; // fail("Entry existed with key =" + threadNum); // } // DiskEntry entry = ((DiskEntry)((LocalRegion)region) // .basicGetEntry(new Integer(threadNum))); // id = entry.getDiskId(); // sizeOfOp = OplogJUnitTest.evaluateSizeOfOperationForPersist( // new Integer(threadNum), val, id, OP_CREATE); // synchronized (OplogJUnitTest.this) { // OplogJUnitTest.this.expectedOplogSize += sizeOfOp; // ++OplogJUnitTest.this.totalSuccessfulOperations; // ++OplogJUnitTest.this.numCreate; // } // } // }); // threads[i].start(); // } // for (int i = 0; i < THREAD_COUNT; ++i) { // DistributedTestCase.join(threads[i], 30 * 1000, null); // } // long currentOplogID = ((LocalRegion)region).getDiskRegion().getChild() // .getOplogId(); // assertTrue( // " Switching did not happen, increase the iterations to insert more data ", // currentOplogID > 1); // for (int j = 1; j < currentOplogID; ++j) { // Oplog oplog = ((LocalRegion)region).getDiskRegion().getChild(j); // // if (oplog != null) { // // DistributedTestCase.join(oplog.getAsynchWriter().getThread(), 10 * 1000, null); // // } // } // assertFalse(failureCause, testFailed); // closeDown(); // } // /** // */ // @Test // public void testMultipleByteBuffersASynchOperations() // { // final int MAX_OPLOG_SIZE = 100000; // diskProps.setMaxOplogSize(MAX_OPLOG_SIZE); // diskProps.setPersistBackup(true); // diskProps.setRolling(false); // diskProps.setSynchronous(false); // diskProps.setOverflow(false); // diskProps.setBytesThreshold(1000); // Oplog.testSetMaxByteBufferSize(100); // LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = true; // final int OP_COUNT = 40; // final byte[] val = new byte[50]; // region = DiskRegionHelperFactory // .getAsyncPersistOnlyRegion(cache, diskProps); // CacheObserver old = CacheObserverHolder // .setInstance(new CacheObserverAdapter() { // public void afterWritingBytes() // { // synchronized (OplogJUnitTest.this) { // flushOccuredAtleastOnce = true; // OplogJUnitTest.this.notify(); // } // } // }); // int sizeOfOp = 0; // DiskId id = null; // for (int i = 0; i < OP_COUNT; ++i) { // try { // region.create(new Integer(i), val); // DiskEntry entry = ((DiskEntry)((LocalRegion)region) // .basicGetEntry(new Integer(i))); // id = entry.getDiskId(); // sizeOfOp += evaluateSizeOfOperationForPersist(new Integer(i), val, id, // OP_CREATE); // } // catch (EntryExistsException e) { // fail("Entry existed with key =" + i); // } // } // Oplog currOplog = ((LocalRegion)region).getDiskRegion().getChild(); // long currentOplogID = currOplog.getOplogId(); // long expectedSize = currOplog.getOplogSize(); // // Ensure that now switching has happned during the operations // assertIndexDetailsEquals(1, currentOplogID); // assertTrue( // "The number of operations did not cause asynch writer to run atleast once , the expected file // size = " // + expectedSize, expectedSize > 1000); // if (!flushOccuredAtleastOnce) { // synchronized (this) { // if (!flushOccuredAtleastOnce) { // try { // this.wait(20000); // } // catch (InterruptedException e) { // fail("No guarantee as flushed occure deven once.Exception=" + e); // } // } // } // } // if (!flushOccuredAtleastOnce) { // fail("In the wait duration , flush did not occur even once. Try increasing the wait time"); // } // long actualFileSize = 0L; // try { // actualFileSize = currOplog.getFileChannel().position(); // } // catch (IOException e) { // fail(e.toString()); // } // assertTrue( // "The number of operations did not cause asynch writer to run atleast once as the actual file // size = " // + actualFileSize, actualFileSize >= 1000); // //currOplog.forceFlush(); // // File opFile = null; // try { // currOplog.getOplogFile(); // } // catch (Exception e) { // logWriter // .error( // "Exception in synching data present in the buffers of RandomAccessFile of Oplog, to the disk", // e); // fail("Test failed because synching of data present in buffer of RandomAccesFile "); // } // actualFileSize = currOplog.getActualFileLength(); // assertTrue( // " The expected Oplog Size not equal to the actual file size. Expected size=" // + expectedSize + " actual size = " + actualFileSize, // expectedSize == actualFileSize); // Oplog.testSetMaxByteBufferSize(Integer.MAX_VALUE); // LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false; // CacheObserverHolder.setInstance(old); // closeDown(); // } /** * Tests the bug which arises in case of asynch mode during oplog switching caused by conflation * of create/destroy operation.The bug occurs if a create operation is followed by destroy but * before destroy proceeds some other operation causes oplog switching * */ @Test public void testBug34615() { final int MAX_OPLOG_SIZE = 100; diskProps.setMaxOplogSize(MAX_OPLOG_SIZE); diskProps.setPersistBackup(true); diskProps.setRolling(false); diskProps.setSynchronous(false); diskProps.setOverflow(false); diskProps.setBytesThreshold(150); LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = true; final byte[] val = new byte[50]; region = DiskRegionHelperFactory.getAsyncPersistOnlyRegion(cache, diskProps); final CacheObserver old = CacheObserverHolder.setInstance(new CacheObserverAdapter() { @Override public void afterConflation(ByteBuffer orig, ByteBuffer conflated) { Thread th = new Thread(new Runnable() { public void run() { region.put("2", new byte[75]); } }); assertNull(conflated); th.start(); ThreadUtils.join(th, 30 * 1000); LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false; } }); region.put("1", val); region.remove("1"); assertFalse(failureCause, testFailed); CacheObserverHolder.setInstance(old); closeDown(); } /** */ @Test public void testConflation() throws Exception { final int MAX_OPLOG_SIZE = 1000; diskProps.setMaxOplogSize(MAX_OPLOG_SIZE); diskProps.setPersistBackup(true); diskProps.setRolling(false); diskProps.setSynchronous(false); diskProps.setOverflow(false); diskProps.setBytesThreshold(1500); final byte[] val = new byte[50]; final byte[][] bb = new byte[2][]; bb[0] = new byte[5]; region = DiskRegionHelperFactory.getAsyncPersistOnlyRegion(cache, diskProps); try { region.put("1", val); region.put("1", new byte[10]); region.put("2", val); region.put("2", new byte[100]); region.create("3", null); region.put("3", new byte[10]); region.create("4", null); region.put("4", new byte[0]); // tests for byte[][] region.create("5", bb); region.put("6", val); region.put("6", bb); region.create("7", null); region.put("7", bb); region.create("8", new byte[9]); region.invalidate("8"); region.create("9", new byte[0]); region.invalidate("9"); region.create("10", new byte[9]); region.localInvalidate("10"); region.create("11", new byte[0]); region.localInvalidate("11"); DiskRegion dr = ((LocalRegion) region).getDiskRegion(); dr.flushForTesting(); byte[] val_1 = ((byte[]) ((LocalRegion) region).getValueOnDisk("1")); assertEquals(val_1.length, 10); byte[] val_2 = ((byte[]) ((LocalRegion) region).getValueOnDisk("2")); assertEquals(val_2.length, 100); byte[] val_3 = ((byte[]) ((LocalRegion) region).getValueOnDisk("3")); assertEquals(val_3.length, 10); byte[] val_4 = ((byte[]) ((LocalRegion) region).getValueOnDisk("4")); assertEquals(val_4.length, 0); byte[][] val_5 = (byte[][]) ((LocalRegion) region).getValueOnDisk("5"); assertEquals(val_5.length, 2); assertEquals(val_5[0].length, 5); assertNull(val_5[1]); byte[][] val_6 = (byte[][]) ((LocalRegion) region).getValueOnDisk("6"); assertEquals(val_6.length, 2); assertEquals(val_6[0].length, 5); assertNull(val_6[1]); byte[][] val_7 = (byte[][]) ((LocalRegion) region).getValueOnDisk("7"); assertEquals(val_7.length, 2); assertEquals(val_7[0].length, 5); assertNull(val_7[1]); Object val_8 = ((LocalRegion) region).getValueOnDisk("8"); assertEquals(val_8, Token.INVALID); Object val_9 = ((LocalRegion) region).getValueOnDisk("9"); assertEquals(val_9, Token.INVALID); Object val_10 = ((LocalRegion) region).getValueOnDisk("10"); assertEquals(val_10, Token.LOCAL_INVALID); Object val_11 = ((LocalRegion) region).getValueOnDisk("11"); assertEquals(val_11, Token.LOCAL_INVALID); } catch (Exception e) { logWriter.error("Exception occured", e); // fail("The test failed due to exception = " + e); throw e; } finally { closeDown(); } } /** * This tests the retrieval of empty byte array when present in asynch buffers * */ @Test public void testGetEmptyByteArrayInAsynchBuffer() { final int MAX_OPLOG_SIZE = 1000; diskProps.setMaxOplogSize(MAX_OPLOG_SIZE); diskProps.setPersistBackup(true); diskProps.setRolling(false); diskProps.setSynchronous(false); diskProps.setOverflow(false); diskProps.setBytesThreshold(1500); final byte[] val = new byte[50]; region = DiskRegionHelperFactory.getAsyncPersistOnlyRegion(cache, diskProps); try { region.put("1", val); region.put("1", new byte[0]); byte[] val_1 = ((byte[]) ((LocalRegion) region).getValueOnDiskOrBuffer("1")); assertEquals(val_1.length, 0); } catch (Exception e) { logWriter.error("Exception occured", e); fail("The test failed due to exception = " + e); } closeDown(); } /** * This tests the retrieval of empty byte array in synch mode * */ @Test public void testGetEmptyByteArrayInSynchMode() { final int MAX_OPLOG_SIZE = 1000; diskProps.setMaxOplogSize(MAX_OPLOG_SIZE); diskProps.setPersistBackup(true); diskProps.setRolling(false); diskProps.setSynchronous(true); diskProps.setOverflow(false); diskProps.setBytesThreshold(1500); final byte[] val = new byte[50]; region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL); try { region.put("1", val); region.put("1", new byte[0]); byte[] val_1 = ((byte[]) ((LocalRegion) region).getValueOnDiskOrBuffer("1")); assertEquals(val_1.length, 0); } catch (Exception e) { logWriter.error("Exception occured", e); fail("The test failed due to exception = " + e); } closeDown(); } /** * This tests the bug which caused the oplogRoller to attempt to roll a removed entry whose value * is Token.Removed This bug can occur if a remove operation causes oplog switching & hence roller * thread gets notified, & the roller thread obtains the iterator of the concurrent region map * before the remove * */ @Test public void testBug34702() { final int MAX_OPLOG_SIZE = 500 * 2; diskProps.setMaxOplogSize(MAX_OPLOG_SIZE); diskProps.setPersistBackup(true); diskProps.setRolling(true); diskProps.setSynchronous(true); diskProps.setOverflow(false); final byte[] val = new byte[200]; proceed = false; region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL); region.put("key1", val); region.put("key2", val); LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = true; final CacheObserver old = CacheObserverHolder.setInstance(new CacheObserverAdapter() { @Override public void afterSettingOplogOffSet(long offset) { ((LocalRegion) region).getDiskRegion().forceRolling(); // Let the operation thread yield to the Roller so that // it is able to obtain the iterator of the concurrrent region map // & thus get the reference to the entry which will contain // value as Token.Removed as the entry though removed from // concurrent // map still will be available to the roller Thread.yield(); // Sleep for some time try { Thread.sleep(5000); } catch (InterruptedException e) { testFailed = true; failureCause = "No guarantee that test is succesful"; fail("No guarantee that test is succesful"); } } @Override public void afterHavingCompacted() { proceed = true; synchronized (OplogJUnitTest.this) { OplogJUnitTest.this.notify(); } } }); try { region.destroy("key1"); region.destroy("key2"); } catch (Exception e1) { LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false; CacheObserverHolder.setInstance(old); fail("Test failed as entry deletion threw exception. Exception = " + e1); } // Wait for some time & check if the after having rolled callabck // is issued sucessfully or not. if (!proceed) { synchronized (this) { if (!proceed) { try { this.wait(20000); } catch (InterruptedException e) { Thread.currentThread().interrupt(); // The test will automatically fail due to proceed flag } } } } assertFalse(failureCause, testFailed); LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false; CacheObserverHolder.setInstance(old); if (!proceed) { fail("Test failed as afterHavingCompacted callabck not issued even after sufficient wait"); } closeDown(); } /** * tests a potential deadlock situation if the operation causing a swithcing of Oplog is waiting * for roller to free space. The problem can arise if the operation causing Oplog switching is * going on an Entry , which already has its oplog ID referring to the Oplog being switched. In * such case, when the roller will try to roll the entries referencing the current oplog , it will * not be able to acquire the lock on the entry as the switching thread has already taken a lock * on it. * */ @Test public void testRollingDeadlockSituation() { final int MAX_OPLOG_SIZE = 2000; diskProps.setMaxOplogSize(MAX_OPLOG_SIZE); diskProps.setPersistBackup(true); diskProps.setRolling(true); diskProps.setSynchronous(true); diskProps.setOverflow(false); diskProps.setDiskDirsAndSizes(new File[] { dirs[0] }, new int[] { 1400 }); final byte[] val = new byte[500]; proceed = false; region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL); region.put("key1", val); region.put("key1", val); try { region.put("key1", val); } catch (DiskAccessException dae) { logWriter.error("Exception occured", dae); fail("Test failed as DiskAccessException was encountered where as the operation should ideally have proceeded without issue . exception = " + dae); } } /** * This tests whether an empty byte array is correctly writtem to the disk as a zero value length * operation & hence the 4 bytes field for recording the value length is absent & also since the * value length is zero no byte for it should also get added. Similary during recover from HTree * as well as Oplog , the empty byte array should be read correctly * */ @Test public void testEmptyByteArrayPutAndRecovery() { CacheObserver old = CacheObserverHolder.setInstance(new CacheObserverAdapter() { @Override public void afterConflation(ByteBuffer origBB, ByteBuffer conflatedBB) { if ((2 + 4 + 1 + EntryEventImpl.serialize("key1").length) != origBB.capacity()) { failureCause = "For a backup region, addition of an empty array should result in an offset of 6 bytes where as actual offset is =" + origBB.capacity(); testFailed = true; } Assert.assertTrue( "For a backup region, addition of an empty array should result in an offset of 6 bytes where as actual offset is =" + origBB.capacity(), (2 + 4 + 1 + EntryEventImpl.serialize("key1").length) == origBB.capacity()); } }); try { final int MAX_OPLOG_SIZE = 2000; diskProps.setMaxOplogSize(MAX_OPLOG_SIZE); diskProps.setPersistBackup(true); // diskProps.setRolling(true); diskProps.setSynchronous(true); diskProps.setOverflow(false); diskProps.setDiskDirsAndSizes(new File[] { dirs[0] }, new int[] { 1400 }); final byte[] val = new byte[0]; LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = true; region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL); region.put("key1", val); LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false; region.close(); region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL); byte[] _val = (byte[]) region.get("key1"); assertTrue( "value of key1 after restarting the region is not an empty byte array. This may indicate problem in reading from Oplog", _val.length == 0); if (this.logWriter.infoEnabled()) { this.logWriter.info( "After first region close & opening again no problems encountered & hence Oplog has been read successfully."); this.logWriter.info( "Closing the region again without any operation done, would indicate that next time data will be loaded from HTree ."); } region.close(); region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL); _val = (byte[]) region.get("key1"); assertTrue( "value of key1 after restarting the region is not an empty byte array. This may indicate problem in reading from HTRee", _val.length == 0); assertFalse(failureCause, testFailed); // region.close(); } finally { LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false; CacheObserverHolder.setInstance(old); } } /** * This is used to test bug 35012 where a remove operation on a key gets unrecorded due to * switching of Oplog if it happens just after the remove operation has destroyed the in memory * entry & is about to acquire the readlock in DiskRegion to record the same. If the Oplog has * switched during that duration , the bug would appear * */ @Test public void testBug35012() { final int MAX_OPLOG_SIZE = 500; diskProps.setMaxOplogSize(MAX_OPLOG_SIZE); diskProps.setPersistBackup(true); diskProps.setRolling(false); diskProps.setSynchronous(true); diskProps.setOverflow(false); final byte[] val = new byte[200]; try { region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL); region.put("key1", val); region.put("key2", val); region.put("key3", val); final Thread th = new Thread(new Runnable() { public void run() { region.remove("key1"); } }); // main thread acquires the write lock ((LocalRegion) region).getDiskRegion().acquireWriteLock(); try { th.start(); Thread.yield(); DiskRegion dr = ((LocalRegion) region).getDiskRegion(); dr.testHook_getChild().forceRolling(dr); } finally { ((LocalRegion) region).getDiskRegion().releaseWriteLock(); } ThreadUtils.join(th, 30 * 1000); region.close(); region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL); assertEquals(region.size(), 2); } catch (Exception e) { this.logWriter.error("Exception occurred ", e); fail("The test could not be completed because of exception .Exception=" + e); } closeDown(); } /** * Tests the various configurable parameters used by the ByteBufferPool . The behaviour of * parameters is based on the mode of DiskRegion ( synch or asynch) . Pls refer to the class * documentation ( Oplog.ByteBufferPool) for the exact behaviour of the class * */ // @Test // public void testByteBufferPoolParameters() // { // // If the mode is asynch , the ByteBuffer obtained should e non direct else // // direct // final int MAX_OPLOG_SIZE = 500; // diskProps.setMaxOplogSize(MAX_OPLOG_SIZE); // diskProps.setPersistBackup(true); // diskProps.setRolling(false); // diskProps.setSynchronous(true); // diskProps.setOverflow(false); // region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps); // List bbPools = ((LocalRegion)region).getDiskRegion().getChild() // .getByteBufferPoolList(); // ByteBuffer bb = ((Oplog.ByteBufferPool)bbPools.get(1)).getBufferFromPool(); // assertTrue(" ByteBuffer is not of type direct", bb.isDirect()); // region.destroyRegion(); // diskProps.setMaxOplogSize(MAX_OPLOG_SIZE); // diskProps.setPersistBackup(true); // diskProps.setRolling(false); // diskProps.setSynchronous(false); // diskProps.setOverflow(false); // region = DiskRegionHelperFactory // .getAsyncPersistOnlyRegion(cache, diskProps); // bbPools = ((LocalRegion)region).getDiskRegion().getChild() // .getByteBufferPoolList(); // bb = ((Oplog.ByteBufferPool)bbPools.get(1)).getBufferFromPool(); // assertTrue(" ByteBuffer is not of type direct", bb.isDirect()); // region.close(); // // Test max pool limit & wait time ( valid only in synch mode). // diskProps.setSynchronous(true); // diskProps.setRegionName("testRegion"); // System.setProperty("/testRegion_MAX_POOL_SIZE", "1"); // System.setProperty("/testRegion_WAIT_TIME", "4000"); // region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps); // bbPools = ((LocalRegion)region).getDiskRegion().getChild() // .getByteBufferPoolList(); // bb = ((Oplog.ByteBufferPool)bbPools.get(1)).getBufferFromPool(); // assertTrue("Since the Pool has one Entry , it should be direct", bb // .isDirect()); // long t1 = System.currentTimeMillis(); // bb = ((Oplog.ByteBufferPool)bbPools.get(1)).getBufferFromPool(); // long t2 = System.currentTimeMillis(); // assertTrue( // "Since the Pool should have been exhausted hence non direct byte buffer should have been // returned", // !bb.isDirect()); // assertTrue("The wait time for ByteBuffer pool was not respected ", // (t2 - t1) > 3000); // region.close(); // // // In case of asynch mode , the upper limit should not have been imposed // // System.setProperty("/testRegion_MAX_POOL_SIZE", "1"); // // System.setProperty("/testRegion_WAIT_TIME", "5000"); // // diskProps.setSynchronous(false); // // diskProps.setRegionName("testRegion"); // // region = DiskRegionHelperFactory // // .getAsyncPersistOnlyRegion(cache, diskProps); // // bbPools = ((LocalRegion)region).getDiskRegion().getChild() // // .getByteBufferPoolList(); // // bb = ((Oplog.ByteBufferPool)bbPools.get(1)).getBufferFromPool(); // // t1 = System.currentTimeMillis(); // // bb = ((Oplog.ByteBufferPool)bbPools.get(1)).getBufferFromPool(); // // t2 = System.currentTimeMillis(); // // assertTrue( // // "There should not have been any wait time " + (t2-t1) + " for ByteBuffer pool ", // // (t2 - t1) / 1000 < 3); // // region.close(); // System.setProperty("/testRegion_MAX_POOL_SIZE", "2"); // System.setProperty("/testRegion_WAIT_TIME", "5000"); // diskProps.setSynchronous(true); // diskProps.setRegionName("testRegion"); // region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps); // bbPools = ((LocalRegion)region).getDiskRegion().getChild() // .getByteBufferPoolList(); // Oplog.ByteBufferPool pool = (Oplog.ByteBufferPool)bbPools.get(1); // ByteBuffer bb1 = pool.getBufferFromPool(); // ByteBuffer bb2 = pool.getBufferFromPool(); // assertIndexDetailsEquals(2, pool.getTotalBuffers()); // assertIndexDetailsEquals(2, pool.getBuffersInUse()); // ((LocalRegion)region).getDiskRegion().getChild().releaseBuffer(bb1); // ((LocalRegion)region).getDiskRegion().getChild().releaseBuffer(bb2); // assertIndexDetailsEquals(0, pool.getBuffersInUse()); // region.close(); // System.setProperty("/testRegion_MAX_POOL_SIZE", "1"); // System.setProperty("/testRegion_WAIT_TIME", "1000"); // diskProps.setSynchronous(true); // diskProps.setRegionName("testRegion"); // region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps); // bbPools = ((LocalRegion)region).getDiskRegion().getChild() // .getByteBufferPoolList(); // pool = (Oplog.ByteBufferPool)bbPools.get(1); // bb1 = pool.getBufferFromPool(); // bb2 = pool.getBufferFromPool(); // assertIndexDetailsEquals(1, pool.getTotalBuffers()); // assertIndexDetailsEquals(1, pool.getBuffersInUse()); // ((LocalRegion)region).getDiskRegion().getChild().releaseBuffer(bb1); // ((LocalRegion)region).getDiskRegion().getChild().releaseBuffer(bb2); // assertIndexDetailsEquals(0, pool.getBuffersInUse()); // closeDown(); // } /** * Tests the ByteBuffer Pool operations for release of ByteBuffers in case the objects being put * vary in size & hence use ByteBuffer Pools present at different indexes * */ // @Test // public void testByteBufferPoolReleaseBugTest() // { // diskProps.setPersistBackup(true); // diskProps.setRolling(false); // diskProps.setSynchronous(true); // diskProps.setOverflow(false); // System.setProperty("/testRegion_UNIT_BUFF_SIZE", "100"); // System.setProperty("/testRegion_UNIT_BUFF_SIZE", "100"); // System.setProperty("gemfire.log-level", getGemFireLogLevel()); // region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps); // region.put("key1", new byte[900]); // region.put("key1", new byte[700]); // closeDown(); // } /** * Tests if buffer size & time are not set , the asynch writer gets awakened on time basis of * default 1 second * */ @Test public void testAsynchWriterAttribBehaviour1() { DiskStoreFactory dsf = cache.createDiskStoreFactory(); ((DiskStoreFactoryImpl) dsf).setMaxOplogSizeInBytes(10000); File dir = new File("testingDirectoryDefault"); dir.mkdir(); dir.deleteOnExit(); File[] dirs = { dir }; dsf.setDiskDirs(dirs); AttributesFactory factory = new AttributesFactory(); final long t1 = System.currentTimeMillis(); DiskStore ds = dsf.create("test"); factory.setDiskSynchronous(false); factory.setDiskStoreName(ds.getName()); factory.setDataPolicy(DataPolicy.PERSISTENT_REPLICATE); factory.setScope(Scope.LOCAL); try { region = cache.createVMRegion("test", factory.createRegionAttributes()); } catch (Exception e1) { logWriter.error("Test failed due to exception", e1); fail("Test failed due to exception " + e1); } LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = true; CacheObserver old = CacheObserverHolder.setInstance( new CacheObserverAdapter() { private long t2; @Override public void goingToFlush() { t2 = System.currentTimeMillis(); delta = t2 - t1; LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false; synchronized (OplogJUnitTest.this) { OplogJUnitTest.this.notify(); } } }); region.put("key1", "111111111111"); synchronized (this) { if (LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER) { try { this.wait(10000); } catch (InterruptedException e) { logWriter.error("Test failed due to exception", e); fail("Test failed due to exception " + e); } assertFalse(LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER); } } CacheObserverHolder.setInstance(old); // Windows clock has an accuracy of 15 ms. Accounting for the same. assertTrue("delta is in miilliseconds=" + delta, delta >= 985); closeDown(); } /** * Tests if buffer size is set but time is not set , the asynch writer gets awakened on buffer * size basis */ @Ignore("TODO:DARREL_DISABLE: test is disabled") @Test public void testAsynchWriterAttribBehaviour2() { DiskStoreFactory dsf = cache.createDiskStoreFactory(); ((DiskStoreFactoryImpl) dsf).setMaxOplogSizeInBytes(10000); dsf.setQueueSize(2); File dir = new File("testingDirectoryDefault"); dir.mkdir(); dir.deleteOnExit(); File[] dirs = { dir }; dsf.setDiskDirs(dirs); AttributesFactory factory = new AttributesFactory(); DiskStore ds = dsf.create("test"); factory.setDiskSynchronous(false); factory.setDiskStoreName(ds.getName()); factory.setDataPolicy(DataPolicy.PERSISTENT_REPLICATE); factory.setScope(Scope.LOCAL); try { region = cache.createVMRegion("test", factory.createRegionAttributes()); } catch (Exception e1) { logWriter.error("Test failed due to exception", e1); fail("Test failed due to exception " + e1); } LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = true; CacheObserver old = CacheObserverHolder.setInstance( new CacheObserverAdapter() { @Override public void goingToFlush() { synchronized (OplogJUnitTest.this) { LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false; OplogJUnitTest.this.notify(); } } }); region.put("key1", new byte[25]); try { Thread.sleep(1000); } catch (InterruptedException e) { logWriter.error("Test failed due to exception", e); fail("Test failed due to exception " + e); } assertTrue(LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER); region.put("key2", new byte[25]); synchronized (this) { if (LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER) { try { OplogJUnitTest.this.wait(10000); assertFalse(LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER); } catch (InterruptedException e2) { logWriter.error("Test failed due to exception", e2); fail("Test failed due to exception " + e2); } } } CacheObserverHolder.setInstance(old); closeDown(); } /** * Tests if buffer size & time interval are explicitly set to zero then the flush will occur due * to asynchForceFlush or due to switching of Oplog * */ @Test public void testAsynchWriterAttribBehaviour3() { DiskStoreFactory dsf = cache.createDiskStoreFactory(); ((DiskStoreFactoryImpl) dsf).setMaxOplogSizeInBytes(500); dsf.setQueueSize(0); dsf.setTimeInterval(0); File dir = new File("testingDirectoryDefault"); dir.mkdir(); dir.deleteOnExit(); File[] dirs = { dir }; dsf.setDiskDirs(dirs); AttributesFactory factory = new AttributesFactory(); DiskStore ds = dsf.create("test"); factory.setDiskSynchronous(false); factory.setDiskStoreName(ds.getName()); factory.setDataPolicy(DataPolicy.PERSISTENT_REPLICATE); factory.setScope(Scope.LOCAL); try { region = cache.createVMRegion("test", factory.createRegionAttributes()); } catch (Exception e1) { logWriter.error("Test failed due to exception", e1); fail("Test failed due to exception " + e1); } LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = true; CacheObserver old = CacheObserverHolder.setInstance( new CacheObserverAdapter() { @Override public void goingToFlush() { LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false; synchronized (OplogJUnitTest.this) { OplogJUnitTest.this.notify(); } } }); try { region.put("key1", new byte[100]); region.put("key2", new byte[100]); region.put("key3", new byte[100]); region.put("key4", new byte[100]); region.put("key5", new byte[100]); Thread.sleep(1000); assertTrue(LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER); } catch (Exception e) { logWriter.error("Test failed due to exception", e); fail("Test failed due to exception " + e); } region.forceRolling(); synchronized (this) { if (LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER) { try { OplogJUnitTest.this.wait(10000); } catch (InterruptedException e2) { logWriter.error("Test failed due to exception", e2); fail("Test failed due to exception " + e2); } } } assertFalse(LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER); CacheObserverHolder.setInstance(old); closeDown(); } /** * Tests if the preblowing of a file with size greater than the disk space available so that * preblowing results in IOException , is able to recover without problem * */ // Now we preallocate spaces for if files and also crfs and drfs. So the below test is not valid // any more. See revision: r42359 and r42320. So disabling this test. @Ignore("TODO: test is disabled") @Test public void testPreblowErrorCondition() { DiskStoreFactory dsf = cache.createDiskStoreFactory(); ((DiskStoreFactoryImpl) dsf).setMaxOplogSizeInBytes(100000000L * 1024L * 1024L * 1024L); dsf.setAutoCompact(false); File dir = new File("testingDirectoryDefault"); dir.mkdir(); dir.deleteOnExit(); File[] dirs = { dir }; int size[] = new int[] { Integer.MAX_VALUE }; dsf.setDiskDirsAndSizes(dirs, size); AttributesFactory factory = new AttributesFactory(); logWriter.info("<ExpectedException action=add>" + "Could not pregrow" + "</ExpectedException>"); try { DiskStore ds = dsf.create("test"); factory.setDiskStoreName(ds.getName()); factory.setDiskSynchronous(true); factory.setDataPolicy(DataPolicy.PERSISTENT_REPLICATE); factory.setScope(Scope.LOCAL); try { region = cache.createVMRegion("test", factory.createRegionAttributes()); } catch (Exception e1) { logWriter.error("Test failed due to exception", e1); fail("Test failed due to exception " + e1); } region.put("key1", new byte[900]); byte[] val = null; try { val = (byte[]) ((LocalRegion) region).getValueOnDisk("key1"); } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); fail(e.toString()); } assertTrue(val.length == 900); } finally { logWriter.info("<ExpectedException action=remove>" + "Could not pregrow" + "</ExpectedException>"); } closeDown(); } /** * Tests if the byte buffer pool in asynch mode tries to contain the pool size * */ @Test public void testByteBufferPoolContainment() { diskProps.setPersistBackup(true); diskProps.setRolling(false); diskProps.setMaxOplogSize(1024 * 1024); diskProps.setSynchronous(false); diskProps.setOverflow(false); diskProps.setBytesThreshold(10); // this is now item count diskProps.setTimeInterval(0); region = DiskRegionHelperFactory.getAsyncPersistOnlyRegion(cache, diskProps); final byte[] val = new byte[1000]; LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = true; CacheObserverHolder.setInstance(new CacheObserverAdapter() { @Override public void goingToFlush() { // Delay flushing assertEquals(10, region.size()); for (int i = 10; i < 20; ++i) { region.put("" + i, val); } synchronized (OplogJUnitTest.this) { OplogJUnitTest.this.notify(); LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false; } } }); for (int i = 0; i < 10; ++i) { region.put("" + i, val); } try { synchronized (OplogJUnitTest.this) { if (LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER) { OplogJUnitTest.this.wait(9000); assertEquals(false, LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER); } } } catch (InterruptedException ie) { fail("interrupted"); } // ((LocalRegion)region).getDiskRegion().getChild().forceFlush(); // int x = ((LocalRegion)region).getDiskRegion().getChild().getAsynchWriter() // .getApproxFreeBuffers(); // assertIndexDetailsEquals(10, x); } // we no longer have a pendingFlushMap // /** // * This test does the following: <br> // * 1)Create a diskRegion with async mode and byte-threshold as 25 bytes. <br> // * 2)Put an entry into the region such that the async-buffer is just over 25 // * bytes and the writer-thread is invoked. <br> // * 3)Using CacheObserver.afterSwitchingWriteAndFlushMaps callback, perform a // * put on the same key just after the async writer thread swaps the // * pendingFlushMap and pendingWriteMap for flushing. <br> // * 4)Using CacheObserver.afterWritingBytes, read the value for key // * (LocalRegion.getValueOnDiskOrBuffer) just after the async writer thread has // * flushed to the disk. <br> // * 5) Verify that the value read in step3 is same as the latest value. This // * will ensure that the flushBufferToggle flag is functioning as expected ( It // * prevents the writer thread from setting the oplog-offset in diskId if that // * particular entry has been updated by a put-thread while the // * async-writer-thread is flushing that entry.) // * // * @throws Exception // */ // @Test // public void testFlushBufferToggleFlag() throws Exception // { // final int MAX_OPLOG_SIZE = 100000; // diskProps.setMaxOplogSize(MAX_OPLOG_SIZE); // diskProps.setPersistBackup(true); // diskProps.setRolling(false); // diskProps.setSynchronous(false); // diskProps.setOverflow(false); // diskProps.setBytesThreshold(25); // LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = true; // region = DiskRegionHelperFactory // .getAsyncPersistOnlyRegion(cache, diskProps); // CacheObserver old = CacheObserverHolder // .setInstance(new CacheObserverAdapter() { // public void afterWritingBytes() // { // LocalRegion localregion = (LocalRegion)region; // try { // valueRead = (String)localregion.getValueOnDiskOrBuffer(KEY); // synchronized (OplogJUnitTest.class) { // proceedForValidation = true; // OplogJUnitTest.class.notify(); // } // } // catch (EntryNotFoundException e) { // e.printStackTrace(); // } // } // public void afterSwitchingWriteAndFlushMaps() // { // region.put(KEY, NEW_VALUE); // } // }); // region.put(KEY, OLD_VALUE); // if (!proceedForValidation) { // synchronized (OplogJUnitTest.class) { // if (!proceedForValidation) { // try { // OplogJUnitTest.class.wait(9000); // assertIndexDetailsEquals(true, proceedForValidation); // } // catch (InterruptedException e) { // fail("interrupted"); // } // } // } // } // cache.getLogger().info("valueRead : " + valueRead); // assertIndexDetailsEquals("valueRead is stale, doesnt match with latest PUT", NEW_VALUE, // valueRead); // LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false; // CacheObserverHolder.setInstance(old); // closeDown(); // } /** * tests async stats are correctly updated */ @Test public void testAsyncStats() throws InterruptedException { diskProps.setBytesThreshold(101); diskProps.setTimeInterval(1000000); region = DiskRegionHelperFactory.getAsyncOverFlowAndPersistRegion(cache, diskProps); final DiskStoreStats dss = ((LocalRegion) region).getDiskRegion().getDiskStore().getStats(); assertEquals(0, dss.getQueueSize()); put100Int(); Awaitility.await().pollInterval(10, TimeUnit.MILLISECONDS).pollDelay(10, TimeUnit.MILLISECONDS) .timeout(10, TimeUnit.SECONDS).until(() -> assertEquals(100, dss.getQueueSize())); assertEquals(0, dss.getFlushes()); region.writeToDisk(); Awaitility.await().pollInterval(10, TimeUnit.MILLISECONDS).pollDelay(10, TimeUnit.MILLISECONDS) .timeout(10, TimeUnit.SECONDS).until(() -> assertEquals(0, dss.getQueueSize())); Awaitility.await().pollInterval(10, TimeUnit.MILLISECONDS).pollDelay(10, TimeUnit.MILLISECONDS) .timeout(10, TimeUnit.SECONDS).until(() -> assertEquals(100, dss.getFlushes())); put100Int(); Awaitility.await().pollInterval(10, TimeUnit.MILLISECONDS).pollDelay(10, TimeUnit.MILLISECONDS) .timeout(10, TimeUnit.SECONDS).until(() -> assertEquals(100, dss.getQueueSize())); region.writeToDisk(); Awaitility.await().pollInterval(10, TimeUnit.MILLISECONDS).pollDelay(10, TimeUnit.MILLISECONDS) .timeout(10, TimeUnit.SECONDS).until(() -> assertEquals(0, dss.getQueueSize())); Awaitility.await().pollInterval(10, TimeUnit.MILLISECONDS).pollDelay(10, TimeUnit.MILLISECONDS) .timeout(10, TimeUnit.SECONDS).until(() -> assertEquals(200, dss.getFlushes())); closeDown(); } /** * Tests delayed creation of DiskID in overflow only mode * */ @Test public void testDelayedDiskIdCreationInOverflowOnlyMode() { diskProps.setPersistBackup(true); diskProps.setRolling(false); diskProps.setMaxOplogSize(1024 * 1024); diskProps.setSynchronous(false); diskProps.setOverflow(true); diskProps.setBytesThreshold(10000); diskProps.setTimeInterval(0); diskProps.setOverFlowCapacity(1); region = DiskRegionHelperFactory.getAsyncOverFlowOnlyRegion(cache, diskProps); final byte[] val = new byte[1000]; region.put("1", val); DiskEntry entry = (DiskEntry) ((LocalRegion) region).basicGetEntry("1"); assertTrue(entry instanceof AbstractDiskLRURegionEntry); assertNull(entry.getDiskId()); region.put("2", val); assertNotNull(entry.getDiskId()); entry = (DiskEntry) ((LocalRegion) region).basicGetEntry("2"); assertTrue(entry instanceof AbstractDiskLRURegionEntry); assertNull(entry.getDiskId()); } /** * Tests immediate creation of DiskID in overflow With Persistence mode * */ @Test public void testImmediateDiskIdCreationInOverflowWithPersistMode() { diskProps.setPersistBackup(true); diskProps.setRolling(false); diskProps.setMaxOplogSize(1024 * 1024); diskProps.setSynchronous(false); diskProps.setOverflow(true); diskProps.setBytesThreshold(10000); diskProps.setTimeInterval(0); diskProps.setOverFlowCapacity(1); region = DiskRegionHelperFactory.getAsyncOverFlowAndPersistRegion(cache, diskProps); final byte[] val = new byte[1000]; region.put("1", val); DiskEntry entry = (DiskEntry) ((LocalRegion) region).basicGetEntry("1"); assertTrue(entry instanceof AbstractDiskLRURegionEntry); assertNotNull(entry.getDiskId()); region.put("2", val); assertNotNull(entry.getDiskId()); entry = (DiskEntry) ((LocalRegion) region).basicGetEntry("2"); assertTrue(entry instanceof AbstractDiskLRURegionEntry); assertNotNull(entry.getDiskId()); } /** * An entry which is evicted to disk will have the flag already written to disk, appropriately set * */ @Test public void testEntryAlreadyWrittenIsCorrectlyUnmarkedForOverflowOnly() throws Exception { try { diskProps.setPersistBackup(false); diskProps.setRolling(false); diskProps.setMaxOplogSize(1024 * 1024); diskProps.setSynchronous(true); diskProps.setOverflow(true); diskProps.setBytesThreshold(10000); diskProps.setTimeInterval(0); diskProps.setOverFlowCapacity(1); region = DiskRegionHelperFactory.getSyncOverFlowOnlyRegion(cache, diskProps); final byte[] val = new byte[1000]; region.put("1", val); region.put("2", val); // "1" should now be on disk region.get("1"); // "2" should now be on disk DiskEntry entry1 = (DiskEntry) ((LocalRegion) region).basicGetEntry("1"); DiskId did1 = entry1.getDiskId(); DiskId.isInstanceofOverflowIntOplogOffsetDiskId(did1); assertTrue(!did1.needsToBeWritten()); region.put("1", "3"); assertTrue(did1.needsToBeWritten()); region.put("2", val); DiskEntry entry2 = (DiskEntry) ((LocalRegion) region).basicGetEntry("2"); DiskId did2 = entry2.getDiskId(); assertTrue(!did2.needsToBeWritten() || !did1.needsToBeWritten()); tearDown(); setUp(); diskProps.setPersistBackup(false); diskProps.setRolling(false); long opsize = Integer.MAX_VALUE; opsize += 100L; diskProps.setMaxOplogSize(opsize); diskProps.setSynchronous(true); diskProps.setOverflow(true); diskProps.setBytesThreshold(10000); diskProps.setTimeInterval(0); diskProps.setOverFlowCapacity(1); region = DiskRegionHelperFactory.getSyncOverFlowOnlyRegion(cache, diskProps); region.put("1", val); region.put("2", val); region.get("1"); entry1 = (DiskEntry) ((LocalRegion) region).basicGetEntry("1"); did1 = entry1.getDiskId(); DiskId.isInstanceofOverflowOnlyWithLongOffset(did1); assertTrue(!did1.needsToBeWritten()); region.put("1", "3"); assertTrue(did1.needsToBeWritten()); region.put("2", "3"); did2 = entry2.getDiskId(); assertTrue(!did2.needsToBeWritten() || !did1.needsToBeWritten()); } catch (Exception e) { e.printStackTrace(); fail(e.toString()); } } /** * An persistent or overflow with persistence entry which is evicted to disk, will have the flag * already written to disk, appropriately set * */ @Test public void testEntryAlreadyWrittenIsCorrectlyUnmarkedForOverflowWithPersistence() { diskProps.setPersistBackup(true); diskProps.setRolling(false); diskProps.setMaxOplogSize(1024 * 1024); diskProps.setSynchronous(true); diskProps.setOverflow(true); diskProps.setBytesThreshold(10000); diskProps.setTimeInterval(0); diskProps.setOverFlowCapacity(1); region = DiskRegionHelperFactory.getSyncOverFlowAndPersistRegion(cache, diskProps); final byte[] val = new byte[1000]; region.put("1", val); DiskEntry entry1 = (DiskEntry) ((LocalRegion) region).basicGetEntry("1"); DiskId did1 = entry1.getDiskId(); DiskId.isInstanceofPersistIntOplogOffsetDiskId(did1); assertTrue(!did1.needsToBeWritten()); region.put("2", val); assertTrue(!did1.needsToBeWritten()); } /** * Tests the various DiskEntry.Helper APIs for correctness as there is now delayed creation of * DiskId and accessing OplogkeyId will throw UnsupportedException */ @Test public void testHelperAPIsForOverflowOnlyRegion() { diskProps.setPersistBackup(false); diskProps.setRolling(false); diskProps.setMaxOplogSize(1024 * 1024); diskProps.setSynchronous(true); diskProps.setOverflow(true); diskProps.setBytesThreshold(10000); diskProps.setTimeInterval(0); diskProps.setOverFlowCapacity(2); region = DiskRegionHelperFactory.getSyncOverFlowOnlyRegion(cache, diskProps); final byte[] val = new byte[1000]; DiskRegion dr = ((LocalRegion) region).getDiskRegion(); region.put("1", val); // region.get("1"); region.put("2", val); // region.get("2"); region.put("3", val); // region.get("3"); DiskEntry entry1 = (DiskEntry) ((LocalRegion) region).basicGetEntry("1"); // DiskId did1 = entry1.getDiskId(); DiskEntry entry2 = (DiskEntry) ((LocalRegion) region).basicGetEntry("2"); // DiskId did2 = entry2.getDiskId(); DiskEntry entry3 = (DiskEntry) ((LocalRegion) region).basicGetEntry("3"); // DiskId did3 = entry3.getDiskId(); assertNull(entry2.getDiskId()); assertNull(entry3.getDiskId()); assertNotNull(entry1.getDiskId()); assertNull(DiskEntry.Helper.getValueOnDisk(entry3, dr)); assertNull(DiskEntry.Helper.getValueOnDisk(entry2, dr)); assertNotNull(DiskEntry.Helper.getValueOnDisk(entry1, dr)); assertNull(DiskEntry.Helper.getValueOnDisk(entry3, dr)); assertNull(DiskEntry.Helper.getValueOnDisk(entry2, dr)); assertNull(entry2.getDiskId()); assertNull(entry3.getDiskId()); assertNotNull(entry1.getDiskId()); assertNull(DiskEntry.Helper.getValueOnDiskOrBuffer(entry3, dr, (LocalRegion) region)); assertNull(DiskEntry.Helper.getValueOnDiskOrBuffer(entry2, dr, (LocalRegion) region)); assertNotNull(DiskEntry.Helper.getValueOnDiskOrBuffer(entry1, dr, (LocalRegion) region)); assertNull(DiskEntry.Helper.getValueOnDisk(entry3, dr)); assertNull(DiskEntry.Helper.getValueOnDisk(entry2, dr)); } /** * Tests the various DiskEntry.Helper APIs for correctness as there is now delayed creation of * DiskId and accessing OplogkeyId will throw UnsupportedException */ @Test public void testHelperAPIsForOverflowWithPersistenceRegion() { helperAPIsForPersistenceWithOrWithoutOverflowRegion(true /* should overflow */); } /** * Tests the various DiskEntry.Helper APIs for correctness as there is now delayed creation of * DiskId and accessing OplogkeyId will throw UnsupportedException */ @Test public void testHelperAPIsForPersistenceRegion() { helperAPIsForPersistenceWithOrWithoutOverflowRegion(false /* should overflow */); } /** * Tests the various DiskEntry.Helper APIs for correctness as there is now delayed creation of * DiskId and accessing OplogkeyId will throw UnsupportedException */ private void helperAPIsForPersistenceWithOrWithoutOverflowRegion(boolean overflow) { diskProps.setPersistBackup(true); diskProps.setRolling(false); diskProps.setMaxOplogSize(1024 * 1024); diskProps.setSynchronous(true); diskProps.setOverflow(overflow); diskProps.setBytesThreshold(10000); diskProps.setTimeInterval(0); diskProps.setOverFlowCapacity(2); region = DiskRegionHelperFactory.getSyncOverFlowAndPersistRegion(cache, diskProps); final byte[] val = new byte[1000]; DiskRegion dr = ((LocalRegion) region).getDiskRegion(); region.put("1", val); // region.get("1"); region.put("2", val); // region.get("2"); region.put("3", val); // region.get("3"); DiskEntry entry1 = (DiskEntry) ((LocalRegion) region).basicGetEntry("1"); // DiskId did1 = entry1.getDiskId(); DiskEntry entry2 = (DiskEntry) ((LocalRegion) region).basicGetEntry("2"); // DiskId did2 = entry2.getDiskId(); DiskEntry entry3 = (DiskEntry) ((LocalRegion) region).basicGetEntry("3"); // DiskId did3 = entry3.getDiskId(); assertNotNull(entry2.getDiskId()); assertNotNull(entry3.getDiskId()); assertNotNull(entry1.getDiskId()); assertNotNull(DiskEntry.Helper.getValueOnDisk(entry3, dr)); assertNotNull(DiskEntry.Helper.getValueOnDisk(entry2, dr)); assertNotNull(DiskEntry.Helper.getValueOnDisk(entry1, dr)); assertNotNull(DiskEntry.Helper.getValueOnDiskOrBuffer(entry3, dr, (LocalRegion) region)); assertNotNull(DiskEntry.Helper.getValueOnDiskOrBuffer(entry2, dr, (LocalRegion) region)); assertNotNull(DiskEntry.Helper.getValueOnDiskOrBuffer(entry1, dr, (LocalRegion) region)); region.close(); region = DiskRegionHelperFactory.getSyncOverFlowAndPersistRegion(cache, diskProps); dr = ((LocalRegion) region).getDiskRegion(); entry1 = (DiskEntry) ((LocalRegion) region).basicGetEntry("1"); // did1 = entry1.getDiskId(); entry2 = (DiskEntry) ((LocalRegion) region).basicGetEntry("2"); // did2 = entry2.getDiskId(); entry3 = (DiskEntry) ((LocalRegion) region).basicGetEntry("3"); // did3 = entry3.getDiskId(); assertNotNull(entry2.getDiskId()); assertNotNull(entry3.getDiskId()); assertNotNull(entry1.getDiskId()); assertNotNull(DiskEntry.Helper.getValueOnDisk(entry3, dr)); assertNotNull(DiskEntry.Helper.getValueOnDisk(entry2, dr)); assertNotNull(DiskEntry.Helper.getValueOnDisk(entry1, dr)); assertNotNull(DiskEntry.Helper.getValueOnDiskOrBuffer(entry3, dr, (LocalRegion) region)); assertNotNull(DiskEntry.Helper.getValueOnDiskOrBuffer(entry2, dr, (LocalRegion) region)); assertNotNull(DiskEntry.Helper.getValueOnDiskOrBuffer(entry1, dr, (LocalRegion) region)); } // @todo this test is failing for some reason. Does it need to be fixed? /** * Bug test to reproduce the bug 37261. The scenario which this test depicts is not actually the * cause of Bug 37261. This test validates the case where a synch persist only entry1 is created * in Oplog1. A put operation on entry2 causes the switch , but before Oplog1 is rolled , the * entry1 is modified so that it references Oplog2. Thus in effect roller will skip rolling entry1 * when rolling Oplog1.Now entry1 is deleted in Oplog2 and then a rolling happens. There should * not be any error */ // @Test // public void testBug37261_1() // { // CacheObserver old = CacheObserverHolder.getInstance(); // try { // // Create a persist only region with rolling true // diskProps.setPersistBackup(true); // diskProps.setRolling(true); // diskProps.setCompactionThreshold(100); // diskProps.setMaxOplogSize(1024); // diskProps.setSynchronous(true); // this.proceed = false; // region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, // diskProps); // // create an entry 1 in oplog1, // region.put("key1", new byte[800]); // // Asif the second put will cause a switch to oplog 2 & also cause the // // oplog1 // // to be submitted to the roller // LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = true; // CacheObserverHolder.setInstance(new CacheObserverAdapter() { // public void beforeGoingToCompact() // { // // modify entry 1 so that it points to the new switched oplog // Thread th = new Thread(new Runnable() { // public void run() // { // region.put("key1", new byte[400]); // } // }); // th.start(); // try { // DistributedTestCase.join(th, 30 * 1000, null); // } // catch (Exception e) { // e.printStackTrace(); // failureCause = e.toString(); // failure = true; // } // } // public void afterHavingCompacted() // { // synchronized (OplogJUnitTest.this) { // rollerThread = Thread.currentThread(); // OplogJUnitTest.this.notify(); // OplogJUnitTest.this.proceed = true; // } // } // }); // region.put("key2", new byte[300]); // synchronized (this) { // if (!this.proceed) { // this.wait(15000); // assertTrue(this.proceed); // } // } // this.proceed = false; // // Asif Delete the 1st entry // region.destroy("key1"); // CacheObserverHolder.setInstance(new CacheObserverAdapter() { // public void afterHavingCompacted() // { // synchronized (OplogJUnitTest.this) { // OplogJUnitTest.this.notify(); // OplogJUnitTest.this.proceed = true; // } // } // }); // // Coz another switch and wait till rolling done // region.put("key2", new byte[900]); // synchronized (this) { // if (!this.proceed) { // this.wait(15000); // assertFalse(this.proceed); // } // } // // Check if the roller is stil alive // assertTrue(rollerThread.isAlive()); // } // catch (Exception e) { // e.printStackTrace(); // fail("Test failed du toe xception" + e); // } // finally { // CacheObserverHolder.setInstance(old); // LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false; // } // } /** * Tests the condition when a 'put' is in progress and concurrent 'clear' and 'put'(on the same * key) occur. Thus if after Htree ref was set (in 'put'), the region got cleared (and same key * re-'put'), the entry will get recorded in the new Oplog without a corresponding create ( * because the Oplogs containing create have already been deleted due to the clear operation). * This put should not proceed. Also, Region creation after closing should not give an exception. */ @Test public void testPutClearPut() { try { // Create a persist only region with rolling true diskProps.setPersistBackup(true); diskProps.setRolling(true); diskProps.setMaxOplogSize(1024); diskProps.setSynchronous(true); this.proceed = false; region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL); final Thread clearOp = new Thread(new Runnable() { public void run() { try { LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false; region.clear(); region.put("key1", "value3"); } catch (Exception e) { testFailed = true; failureCause = "Encountered Exception=" + e; } } }); region.getAttributesMutator().setCacheWriter(new CacheWriterAdapter() { @Override public void beforeUpdate(EntryEvent event) throws CacheWriterException { clearOp.start(); } }); try { ThreadUtils.join(clearOp, 30 * 1000); } catch (Exception e) { testFailed = true; failureCause = "Encountered Exception=" + e; e.printStackTrace(); } region.create("key1", "value1"); LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = true; region.put("key1", "value2"); if (!testFailed) { region.close(); region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL); } else { fail(failureCause); } } catch (Exception e) { e.printStackTrace(); fail("Test failed due to exception" + e); } finally { testFailed = false; proceed = false; LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false; } } /** * Tests the condition when a 'put' on an alreay created entry and concurrent 'clear' are * happening. Thus if after HTree ref was set (in 'put'), the region got cleared (and same key * re-'put'), the entry will actually become a create in the VM The new Oplog should record it as * a create even though the Htree ref in ThreadLocal will not match with the current Htree Ref. * But the operation is valid & should get recorded in Oplog * */ @Test public void testPutClearCreate() { failure = false; try { // Create a persist only region with rolling true diskProps.setPersistBackup(true); diskProps.setRolling(true); diskProps.setMaxOplogSize(1024); diskProps.setSynchronous(true); region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL); region.create("key1", "value1"); LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = true; CacheObserverHolder.setInstance(new CacheObserverAdapter() { @Override public void afterSettingDiskRef() { Thread clearTh = new Thread(new Runnable() { public void run() { region.clear(); } }); clearTh.start(); try { ThreadUtils.join(clearTh, 120 * 1000); failure = clearTh.isAlive(); failureCause = "Clear Thread still running !"; } catch (Exception e) { failure = true; failureCause = e.toString(); } } }); region.put("key1", "value2"); LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false; assertFalse(failureCause, failure); assertEquals(1, region.size()); region.close(); region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL); assertEquals(1, region.size()); assertEquals("value2", (String) region.get("key1")); } catch (Exception e) { e.printStackTrace(); fail("Test failed due to exception" + e); } finally { testFailed = false; proceed = false; LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false; CacheObserverHolder.setInstance(new CacheObserverAdapter()); failure = false; } } /** * Tests if 'destroy' transaction is working correctly for sync-overflow-only disk region entry */ @Test public void testOverFlowOnlySyncDestroyTx() { diskProps.setMaxOplogSize(20480); diskProps.setOverFlowCapacity(1); diskProps.setDiskDirs(dirs); region = DiskRegionHelperFactory.getSyncOverFlowOnlyRegion(cache, diskProps); assertNotNull(region); region.put("key", "createValue"); region.put("key1", "createValue1"); try { cache.getCacheTransactionManager().begin(); region.destroy("key"); cache.getCacheTransactionManager().commit(); assertNull("The deleted entry should have been null", ((LocalRegion) region).entries.getEntry("key")); } catch (CommitConflictException e) { testFailed = true; fail("CommitConflitException encountered"); } catch (Exception e) { e.printStackTrace(); fail("Test failed due to exception" + e); } } /** * Test to force a recovery to follow the path of switchOutFilesForRecovery and ensuring that * IOExceptions do not come as a result. This is also a bug test for bug 37682 * * @throws Exception */ @Test public void testSwitchFilesForRecovery() throws Exception { region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, null, Scope.LOCAL); put100Int(); region.forceRolling(); Thread.sleep(2000); put100Int(); int sizeOfRegion = region.size(); region.close(); // this variable will set to false in the src code itself // NewLBHTreeDiskRegion.setJdbmexceptionOccuredToTrueForTesting = true; try { region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, null, Scope.LOCAL); } catch (Exception e) { fail("failed in recreating region due to" + e); } finally { // NewLBHTreeDiskRegion.setJdbmexceptionOccuredToTrueForTesting = false; } if (sizeOfRegion != region.size()) { fail(" Expected region size to be " + sizeOfRegion + " after recovery but it is " + region.size()); } } /** * tests directory stats are correctly updated in case of single directory (for bug 37531) */ @Test public void testPersist1DirStats() { final AtomicBoolean freezeRoller = new AtomicBoolean(); CacheObserver old = CacheObserverHolder.setInstance(new CacheObserverAdapter() { private volatile boolean didBeforeCall = false; @Override public void beforeGoingToCompact() { this.didBeforeCall = true; synchronized (freezeRoller) { if (!assertDone) { try { // Here, we are not allowing the Roller thread to roll the old oplog into htree while (!freezeRoller.get()) { freezeRoller.wait(); } freezeRoller.set(false); } catch (InterruptedException e) { fail("interrupted"); } } } } @Override public void afterHavingCompacted() { if (this.didBeforeCall) { this.didBeforeCall = false; LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false; // assertTrue("Assert failure for DSpaceUsage in afterHavingCompacted ", // diskSpaceUsageStats() == calculatedDiskSpaceUsageStats()); // what is the point of this assert? checkDiskStats(); } } }); try { final int MAX_OPLOG_SIZE = 500; diskProps.setMaxOplogSize(MAX_OPLOG_SIZE); diskProps.setPersistBackup(true); diskProps.setRolling(true); diskProps.setSynchronous(true); diskProps.setOverflow(false); diskProps.setDiskDirsAndSizes(new File[] { dirs[0] }, new int[] { 4000 }); final byte[] val = new byte[200]; region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL); LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = true; region.put("key1", val); // Disk space should have changed due to 1 put // assertTrue("stats did not increase after put 1 ", diskSpaceUsageStats() == // calculatedDiskSpaceUsageStats()); checkDiskStats(); region.put("key2", val); // assertTrue("stats did not increase after put 2", diskSpaceUsageStats() == // calculatedDiskSpaceUsageStats()); checkDiskStats(); // This put will cause a switch as max-oplog size (500) will be exceeded (600) region.put("key3", val); synchronized (freezeRoller) { // assertTrue("current disk space usage with Roller thread in wait and put key3 done is // incorrect " + diskSpaceUsageStats() + " " + calculatedDiskSpaceUsageStats(), // diskSpaceUsageStats()== calculatedDiskSpaceUsageStats()); checkDiskStats(); assertDone = true; freezeRoller.set(true); freezeRoller.notifyAll(); } region.close(); closeDown(); // Stop rolling to get accurate estimates: diskProps.setRolling(false); region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL); // On recreating the region after closing, old Oplog file gets rolled into htree // "Disk space usage zero when region recreated" checkDiskStats(); region.put("key4", val); // assertTrue("stats did not increase after put 4", diskSpaceUsageStats() == // calculatedDiskSpaceUsageStats()); checkDiskStats(); region.put("key5", val); // assertTrue("stats did not increase after put 5", diskSpaceUsageStats() == // calculatedDiskSpaceUsageStats()); checkDiskStats(); assertDone = false; LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = true; region.put("key6", val); // again we expect a switch in oplog here synchronized (freezeRoller) { // assertTrue("current disk space usage with Roller thread in wait and put key6 done is // incorrect", diskSpaceUsageStats()== calculatedDiskSpaceUsageStats()); checkDiskStats(); assertDone = true; freezeRoller.set(true); freezeRoller.notifyAll(); } region.close(); } catch (Exception e) { e.printStackTrace(); fail("Test failed due to exception" + e); } finally { LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false; CacheObserverHolder.setInstance(old); synchronized (freezeRoller) { assertDone = true; freezeRoller.set(true); freezeRoller.notifyAll(); } } } /** * Tests reduction in size of disk stats when the oplog is rolled. */ @Category(FlakyTest.class) // GEODE-527: jvm sizing sensitive, non-thread-safe test hooks, time // sensitive @Test public void testStatsSizeReductionOnRolling() throws Exception { final int MAX_OPLOG_SIZE = 500 * 2; diskProps.setMaxOplogSize(MAX_OPLOG_SIZE); diskProps.setPersistBackup(true); diskProps.setRolling(true); diskProps.setCompactionThreshold(100); diskProps.setSynchronous(true); diskProps.setOverflow(false); diskProps.setDiskDirsAndSizes(new File[] { dirs[0] }, new int[] { 4000 }); final byte[] val = new byte[333]; region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL); final DiskRegion dr = ((LocalRegion) region).getDiskRegion(); final Object lock = new Object(); final boolean[] exceptionOccured = new boolean[] { true }; final boolean[] okToExit = new boolean[] { false }; final boolean[] switchExpected = new boolean[] { false }; // calculate sizes final int extra_byte_num_per_entry = InternalDataSerializer .calculateBytesForTSandDSID(getDSID((LocalRegion) region)); final int key3_size = DiskOfflineCompactionJUnitTest.getSize4Create(extra_byte_num_per_entry, "key3", val); final int tombstone_key1 = DiskOfflineCompactionJUnitTest.getSize4TombstoneWithKey(extra_byte_num_per_entry, "key1"); final int tombstone_key2 = DiskOfflineCompactionJUnitTest.getSize4TombstoneWithKey(extra_byte_num_per_entry, "key2"); // TODO: move static methods from DiskOfflineCompactionJUnitTest to shared util class CacheObserver old = CacheObserverHolder.setInstance(new CacheObserverAdapter() { private long before = -1; private DirectoryHolder dh = null; private long oplogsSize = 0; @Override public void beforeSwitchingOplog() { cache.getLogger().info("beforeSwitchingOplog"); if (!switchExpected[0]) { fail("unexpected oplog switch"); } if (before == -1) { // only want to call this once; before the 1st oplog destroy this.dh = dr.getNextDir(); this.before = this.dh.getDirStatsDiskSpaceUsage(); } } @Override public void beforeDeletingCompactedOplog(Oplog oplog) { cache.getLogger().info("beforeDeletingCompactedOplog"); oplogsSize += oplog.getOplogSize(); } @Override public void afterHavingCompacted() { cache.getLogger().info("afterHavingCompacted"); if (before > -1) { synchronized (lock) { okToExit[0] = true; long after = this.dh.getDirStatsDiskSpaceUsage(); // after compaction, in _2.crf, key3 is an create-entry, // key1 and key2 are tombstones. // _2.drf contained a rvvgc with drMap.size()==1 int expected_drf_size = Oplog.OPLOG_DISK_STORE_REC_SIZE + Oplog.OPLOG_MAGIC_SEQ_REC_SIZE + Oplog.OPLOG_GEMFIRE_VERSION_REC_SIZE + DiskOfflineCompactionJUnitTest.getRVVSize(1, new int[] { 0 }, true); int expected_crf_size = Oplog.OPLOG_DISK_STORE_REC_SIZE + Oplog.OPLOG_MAGIC_SEQ_REC_SIZE + Oplog.OPLOG_GEMFIRE_VERSION_REC_SIZE + DiskOfflineCompactionJUnitTest.getRVVSize(1, new int[] { 1 }, false) + Oplog.OPLOG_NEW_ENTRY_BASE_REC_SIZE + key3_size + tombstone_key1 + tombstone_key2; int oplog_2_size = expected_drf_size + expected_crf_size; if (after != oplog_2_size) { cache.getLogger().info("test failed before=" + before + " after=" + after + " oplogsSize=" + oplogsSize); exceptionOccured[0] = true; } else { exceptionOccured[0] = false; } LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false; lock.notify(); } } } }); try { LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = true; cache.getLogger().info("putting key1"); region.put("key1", val); // Disk space should have changed due to 1 put // assertTrue("stats did not increase after put 1 ", diskSpaceUsageStats() == // calculatedDiskSpaceUsageStats()); checkDiskStats(); cache.getLogger().info("putting key2"); region.put("key2", val); // assertTrue("stats did not increase after put 2", diskSpaceUsageStats() == // calculatedDiskSpaceUsageStats()); checkDiskStats(); cache.getLogger().info("removing key1"); region.remove("key1"); cache.getLogger().info("removing key2"); region.remove("key2"); // This put will cause a switch as max-oplog size (900) will be exceeded (999) switchExpected[0] = true; cache.getLogger().info("putting key3"); region.put("key3", val); cache.getLogger().info("waiting for compaction"); synchronized (lock) { if (!okToExit[0]) { lock.wait(9000); assertTrue(okToExit[0]); } assertFalse(exceptionOccured[0]); } region.close(); } finally { LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false; CacheObserverHolder.setInstance(old); } } // @todo this test is broken; size1 can keep changing since the roller will // keep copying forward forever. Need to change it so copy forward oplogs // will not be compacted so that size1 reaches a steady state /** * Tests stats verification with rolling enabled */ // @Test // public void testSizeStatsAfterRecreationWithRollingEnabled() throws Exception // { // final int MAX_OPLOG_SIZE = 500; // diskProps.setMaxOplogSize(MAX_OPLOG_SIZE); // diskProps.setPersistBackup(true); // diskProps.setRolling(true); // diskProps.setCompactionThreshold(100); // diskProps.setSynchronous(true); // diskProps.setOverflow(false); // diskProps.setDiskDirsAndSizes(new File[] { dirs[0] }, new int[] { 4000 }); // final byte[] val = new byte[200]; // region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, // diskProps); // final DiskRegion dr = ((LocalRegion)region).getDiskRegion(); // final Object lock = new Object(); // final boolean [] exceptionOccured = new boolean[] {true}; // final boolean [] okToExit = new boolean[] {false}; // CacheObserver old = CacheObserverHolder // .setInstance(new CacheObserverAdapter() { // private long before = -1; // public void beforeDeletingCompactedOplog(Oplog rolledOplog) // { // if (before == -1) { // // only want to call this once; before the 1st oplog destroy // before = dr.getNextDir().getDirStatsDiskSpaceUsage(); // } // } // public void afterHavingCompacted() { // if(before > -1) { // synchronized(lock) { // okToExit[0] = true; // long after = dr.getNextDir().getDirStatsDiskSpaceUsage();; // exceptionOccured[0] = false; // LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false; // lock.notify(); // } // } // } // }); // try { // LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = true; // region.put("key1", val); // region.put("key2", val); // // This put will cause a switch as max-oplog size (500) will be exceeded (600) // region.put("key3", val); // synchronized(lock) { // if (!okToExit[0]) { // lock.wait(9000); // assertTrue(okToExit[0]); // } // assertFalse(exceptionOccured[0]); // } // while (region.forceCompaction() != null) { // // wait until no more oplogs to compact // Thread.sleep(50); // } // long size1 =0; // for(DirectoryHolder dh:dr.getDirectories()) { // cache.getLogger().info(" dir=" + dh.getDir() // + " size1=" + dh.getDirStatsDiskSpaceUsage()); // size1 += dh.getDirStatsDiskSpaceUsage(); // } // System.out.println("Size before closing= "+ size1); // region.close(); // diskProps.setRolling(false); // region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, // diskProps); // long size2 =0; // for(DirectoryHolder dh:((LocalRegion)region).getDiskRegion().getDirectories()) { // cache.getLogger().info(" dir=" + dh.getDir() // + " size2=" + dh.getDirStatsDiskSpaceUsage()); // size2 += dh.getDirStatsDiskSpaceUsage(); // } // System.out.println("Size after recreation= "+ size2); // assertIndexDetailsEquals(size1, size2); // region.close(); // } // finally { // LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false; // CacheObserverHolder.setInstance(old); // } // } // This test is not valid. When listenForDataSerializeChanges is called // it ALWAYS does vrecman writes and a commit. Look at saveInstantiators // and saveDataSerializers to see these commit calls. // These calls can cause the size of the files to change. /** * Tests if without rolling the region size before close is same as after recreation */ @Test public void testSizeStatsAfterRecreation() throws Exception { final int MAX_OPLOG_SIZE = 500; diskProps.setMaxOplogSize(MAX_OPLOG_SIZE); diskProps.setPersistBackup(true); diskProps.setRolling(false); diskProps.setSynchronous(true); diskProps.setOverflow(false); diskProps.setDiskDirsAndSizes(new File[] { dirs[0], dirs[1] }, new int[] { 4000, 4000 }); final byte[] val = new byte[200]; region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL); DiskRegion dr = ((LocalRegion) region).getDiskRegion(); try { LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = true; for (int i = 0; i < 8; ++i) { region.put("key" + i, val); } long size1 = 0; for (DirectoryHolder dh : dr.getDirectories()) { size1 += dh.getDirStatsDiskSpaceUsage(); } System.out.println("Size before close = " + size1); region.close(); region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL); dr = ((LocalRegion) region).getDiskRegion(); long size2 = 0; for (DirectoryHolder dh : dr.getDirectories()) { size2 += dh.getDirStatsDiskSpaceUsage(); } System.out.println("Size after recreation= " + size2); assertEquals(size1, size2); region.close(); } finally { LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false; } } @Test public void testUnPreblowOnRegionCreate() throws Exception { final int MAX_OPLOG_SIZE = 20000; diskProps.setMaxOplogSize(MAX_OPLOG_SIZE); diskProps.setPersistBackup(true); diskProps.setRolling(true); diskProps.setSynchronous(true); diskProps.setOverflow(false); diskProps.setDiskDirsAndSizes(new File[] { dirs[0] }, new int[] { 40000 }); region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL); try { LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = true; for (int i = 0; i < 10; ++i) { region.put("key-" + i, "value-"); } assertEquals(18000, getOplogFileSizeSum(dirs[0], ".crf")); assertEquals(2000, getOplogFileSizeSum(dirs[0], ".drf")); // make a copy of inflated crf. use this to replace compacted crf to // simulate incomplete diskStore close File[] files = dirs[0].listFiles(); for (File file : files) { if (file.getName().endsWith(".crf") || file.getName().endsWith(".drf")) { File inflated = new File(file.getAbsolutePath() + "_inflated"); FileUtils.copyFile(file, inflated); } } cache.close(); assertTrue(500 > getOplogFileSizeSum(dirs[0], ".crf")); assertTrue(100 > getOplogFileSizeSum(dirs[0], ".drf")); // replace compacted crf with inflated crf and remove krf files = dirs[0].listFiles(); for (File file : files) { String name = file.getName(); if (name.endsWith(".krf") || name.endsWith(".crf") || name.endsWith(".drf")) { file.delete(); } } for (File file : files) { String name = file.getName(); if (name.endsWith("_inflated")) { assertTrue(file.renameTo(new File(file.getAbsolutePath().replace("_inflated", "")))); } } assertEquals(18000, getOplogFileSizeSum(dirs[0], ".crf")); assertEquals(2000, getOplogFileSizeSum(dirs[0], ".drf")); createCache(); region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL); for (int i = 10; i < 20; ++i) { region.put("key-" + i, "value-"); } int sizeCrf = getOplogFileSizeSum(dirs[0], ".crf"); assertTrue("crf too big:" + sizeCrf, sizeCrf < 18000 + 500); assertTrue("crf too small:" + sizeCrf, sizeCrf > 18000); int sizeDrf = getOplogFileSizeSum(dirs[0], ".drf"); assertTrue("drf too big:" + sizeDrf, sizeDrf < 2000 + 100); assertTrue("drf too small:" + sizeDrf, sizeDrf > 2000); // test that region recovery does not cause unpreblow region.close(); region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL); assertEquals(sizeCrf, getOplogFileSizeSum(dirs[0], ".crf")); assertEquals(sizeDrf, getOplogFileSizeSum(dirs[0], ".drf")); } finally { LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false; } } private int getOplogFileSizeSum(File dir, String type) { int sum = 0; File[] files = dir.listFiles(); for (File file : files) { String name = file.getName(); if (name.endsWith(type)) { sum += file.length(); } } return sum; } @Test public void testMagicSeqPresence() throws Exception { final int MAX_OPLOG_SIZE = 200; diskProps.setMaxOplogSize(MAX_OPLOG_SIZE); diskProps.setPersistBackup(true); diskProps.setRolling(true); diskProps.setSynchronous(true); diskProps.setOverflow(false); diskProps.setDiskDirsAndSizes(new File[] { dirs[0] }, new int[] { 4000 }); region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL); // 3 types of oplog files will be verified verifyOplogHeader(dirs[0], ".if", ".crf", ".drf"); try { LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = true; IntStream.range(0, 20).forEach(i -> region.put("key-" + i, "value-" + i)); // krf is created, so 4 types of oplog files will be verified verifyOplogHeader(dirs[0], ".if", ".crf", ".drf", ".krf"); region.close(); region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL); verifyOplogHeader(dirs[0], ".if", ".crf", ".drf", ".krf"); region.close(); } finally { LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false; } } private void verifyOplogHeader(File dir, String... oplogTypes) throws IOException { Awaitility.await().atMost(5, TimeUnit.SECONDS).until(() -> { List<String> types = new ArrayList<>(Arrays.asList(oplogTypes)); Arrays.stream(dir.listFiles()).map(File::getName).map(f -> f.substring(f.indexOf("."))) .forEach(types::remove); return types.isEmpty(); }); File[] files = dir.listFiles(); HashSet<String> verified = new HashSet<String>(); for (File file : files) { String name = file.getName(); byte[] expect = new byte[Oplog.OPLOG_MAGIC_SEQ_REC_SIZE]; if (name.endsWith(".crf")) { expect[0] = Oplog.OPLOG_MAGIC_SEQ_ID; System.arraycopy(OPLOG_TYPE.CRF.getBytes(), 0, expect, 1, OPLOG_TYPE.getLen()); verified.add(".crf"); } else if (name.endsWith(".drf")) { expect[0] = Oplog.OPLOG_MAGIC_SEQ_ID; System.arraycopy(OPLOG_TYPE.DRF.getBytes(), 0, expect, 1, OPLOG_TYPE.getLen()); verified.add(".drf"); } else if (name.endsWith(".krf")) { expect[0] = Oplog.OPLOG_MAGIC_SEQ_ID; System.arraycopy(OPLOG_TYPE.KRF.getBytes(), 0, expect, 1, OPLOG_TYPE.getLen()); verified.add(".krf"); } else if (name.endsWith(".if")) { expect[0] = DiskInitFile.OPLOG_MAGIC_SEQ_ID; System.arraycopy(OPLOG_TYPE.IF.getBytes(), 0, expect, 1, OPLOG_TYPE.getLen()); verified.add(".if"); } else { System.out.println("Ignored: " + file); continue; } expect[expect.length - 1] = 21; // EndOfRecord byte[] buf = new byte[Oplog.OPLOG_MAGIC_SEQ_REC_SIZE]; FileInputStream fis = new FileInputStream(file); int count = fis.read(buf, 0, 8); fis.close(); System.out.println("Verifying: " + file); assertEquals("expected a read to return 8 but it returned " + count + " for file " + file, 8, count); assertTrue(Arrays.equals(expect, buf)); } assertEquals(oplogTypes.length, verified.size()); } /** * Tests if without rolling the region size before close is same as after recreation */ @Test public void testSizeStatsAfterRecreationInAsynchMode() throws Exception { final int MAX_OPLOG_SIZE = 1000; diskProps.setMaxOplogSize(MAX_OPLOG_SIZE); diskProps.setPersistBackup(true); diskProps.setRolling(false); diskProps.setSynchronous(false); diskProps.setBytesThreshold(800); diskProps.setOverflow(false); diskProps.setDiskDirsAndSizes(new File[] { dirs[0], dirs[1] }, new int[] { 4000, 4000 }); final byte[] val = new byte[25]; region = DiskRegionHelperFactory.getAsyncPersistOnlyRegion(cache, diskProps); DiskRegion dr = ((LocalRegion) region).getDiskRegion(); try { LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = true; for (int i = 0; i < 42; ++i) { region.put("key" + i, val); } // need to wait for writes to happen before getting size dr.flushForTesting(); long size1 = 0; for (DirectoryHolder dh : dr.getDirectories()) { size1 += dh.getDirStatsDiskSpaceUsage(); } System.out.println("Size before close = " + size1); region.close(); diskProps.setSynchronous(true); region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL); dr = ((LocalRegion) region).getDiskRegion(); long size2 = 0; for (DirectoryHolder dh : dr.getDirectories()) { size2 += dh.getDirStatsDiskSpaceUsage(); } System.out.println("Size after recreation= " + size2); assertEquals(size1, size2); region.close(); } finally { LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false; } } @Test public void testAsynchModeStatsBehaviour() throws Exception { final int MAX_OPLOG_SIZE = 1000; diskProps.setMaxOplogSize(MAX_OPLOG_SIZE); diskProps.setPersistBackup(true); diskProps.setRolling(false); diskProps.setSynchronous(false); diskProps.setBytesThreshold(800); diskProps.setTimeInterval(Long.MAX_VALUE); diskProps.setOverflow(false); diskProps.setDiskDirsAndSizes(new File[] { dirs[0] }, new int[] { 4000 }); final byte[] val = new byte[25]; region = DiskRegionHelperFactory.getAsyncPersistOnlyRegion(cache, diskProps); DiskRegion dr = ((LocalRegion) region).getDiskRegion(); try { LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = true; for (int i = 0; i < 4; ++i) { region.put("key" + i, val); } // This test now has a race condition in it since // async puts no longer increment disk space. // It is not until a everything is flushed that we will know the disk size. dr.flushForTesting(); checkDiskStats(); long size1 = 0; for (DirectoryHolder dh : dr.getDirectories()) { size1 += dh.getDirStatsDiskSpaceUsage(); } System.out.println("Size before close = " + size1); region.close(); diskProps.setSynchronous(true); region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL); dr = ((LocalRegion) region).getDiskRegion(); long size2 = 0; for (DirectoryHolder dh : dr.getDirectories()) { size2 += dh.getDirStatsDiskSpaceUsage(); } System.out.println("Size after recreation= " + size2); assertEquals(size1, size2); region.close(); } finally { LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false; } } protected long diskSpaceUsageStats() { return ((LocalRegion) region).getDiskRegion().getInfoFileDir().getDirStatsDiskSpaceUsage(); } protected long calculatedDiskSpaceUsageStats() { long oplogSize = oplogSize(); // cache.getLogger().info(" oplogSize=" + oplogSize // + " statSize=" + diskSpaceUsageStats()); return oplogSize; } private void checkDiskStats() { long actualDiskStats = diskSpaceUsageStats(); long computedDiskStats = calculatedDiskSpaceUsageStats(); int tries = 0; while (actualDiskStats != computedDiskStats && tries++ <= 100) { // race conditions exist in which the stats change try { Thread.sleep(100); } catch (InterruptedException ignore) { } actualDiskStats = diskSpaceUsageStats(); computedDiskStats = calculatedDiskSpaceUsageStats(); } assertEquals(computedDiskStats, actualDiskStats); } private long oplogSize() { long size = ((LocalRegion) region).getDiskRegion().getDiskStore().undeletedOplogSize.get(); // cache.getLogger().info("undeletedOplogSize=" + size); Oplog[] opArray = ((LocalRegion) region).getDiskRegion().getDiskStore().persistentOplogs.getAllOplogs(); if ((opArray != null) && (opArray.length != 0)) { for (int j = 0; j < opArray.length; ++j) { size += opArray[j].getOplogSize(); // cache.getLogger().info("oplog#" + opArray[j].getOplogId() // + ".size=" + opArray[j].getOplogSize()); } } return size; } private int getDSID(LocalRegion lr) { return lr.getDistributionManager().getDistributedSystemId(); } }