Merge lp:~pbeaman/akiban-persistit/fix_1018526_temp_trees_in_journal into lp:akiban-persistit

[Peter Beaman]

Fix bug1018526 in which every tree created in a temporary volume has an Identify Tree (IT) record in the journal.

Removes proactive call to JournalManager#handleForTree in VolumeStructure#getTree and instead lets tree handles be created lazily.

Adds a test to verify that no records are written to the journal within a transaction if only temporary volumes are modified.

[Peter Beaman (pbeaman)]

After reconsideration I'm going to add code to remove temporary trees from the _handleToTreeMap on recovery. This will clean up any mess at customer sites related to this bug when we install this update and restart the server.

review: Needs Fixing

[Nathan Williams (nwilliams)]

What is the intended lifetime of the tree handle now? It looks like it will get created on remove key, remove tree, store key, and accumulator delta inside of a transaction. It looks like _ignoreTransactions hould always mirror isTemporary but it is up to the caller. Maybe an assert inside of JournalManager#handleForTree() would be nice.

A couple of the checks for handle != 0 are also slightly confusing. We shouldn't have MVVs in a temporary tree (txns being ignored) so if we are pruning, we should always have a handle. Similarly, how could we get an index hole if they can't be shared across threads and aren't recovered?

The new test with the "upper bound" to avoid a checkpoint race. We already have a couple intermittent test failures, it would be nice to structure this so it is always deterministic.

review: Needs Information

[Peter Beaman (pbeaman)]

Added code to detect IT records that refer to temporary volumes during recovery. Such trees are not restored into the handleToTreeMap and treeToHandleMap collections, so that when the journal next rolls over, the recorded tree map will contain only permanent trees and volumes. This logic will fix up existing systems.

Once we have had this version in the field on all sites we can then remove the cleanup code.

Note that from the information in the journal, the detection of a temporary volume is somewhat ad hoc. It is known by the conjunction of two things:

id value is 12345 (for no very good reason temporary volumes have all been marked with that ID number)
name ends with "_temporary_volume"

We feel it is unlikely there are any non-temporary volumes that have these two conditions at this time. However, eventually the detection code should be removed since it is less than perfectly precise.

review: Needs Resubmitting

[Peter Beaman (pbeaman)]

Responses to Nathan:

What is the intended lifetime of the tree handle now? It looks like it will get created on remove key, remove tree, store key, and accumulator delta inside of a transaction. -- Correct

It looks like _ignoreTransactions hould always mirror isTemporary but it is up to the caller. - Not quite: currently the directory tree exchange operates with _ignoreTransactions on non-temporary volumes.

Maybe an assert inside of JournalManager#handleForTree() would be nice. - Added

A couple of the checks for handle != 0 are also slightly confusing. We shouldn't have MVVs in a temporary tree (txns being ignored) so if we are pruning, we should always have a handle. - Correct. Changed to asserts.

Similarly, how could we get an index hole if they can't be shared across threads and aren't recovered? - There's an obscure, gnarly re-balance case in raw_removeKeyRangeInternal that can leave an index hole. A fix for another bug may remove it, but for now since we think it can happen, the condition in walkRight should be retained.

The new test with the "upper bound" to avoid a checkpoint race. We already have a couple intermittent test failures, it would be nice to structure this so it is always deterministic. - Yes. I suggest we should do that comprehensively in a different branch.

[Nathan Williams (nwilliams)]

Thanks for the changes, looks good.

review: Approve

[Akiban Build User (build-akiban)]

There were 2 failures during build/test:

* job persistit-build failed at build number 374: http://172.16.20.104:8080/job/persistit-build/374/

* view must-pass failed: persistit-build is yellow

review: Needs Fixing

[lp:~pbeaman/akiban-persistit/fix_1018526_temp_trees_in_journal]

334. By Peter Beaman on 2012-06-28

Always allocate tree handles for permanent trees

[Peter Beaman (pbeaman)]

Modified the protocol yet again. Tree handles are now assigned on non-temporary trees as soon as the tree object is created. This permits the Exchange#fetchFromValueInternal to enqueue pages with MVVs before any transaction modifies the tree. (Otherwise the conditional on handle != 0 is required in that code path.) Since this behavior is more similar to what we currently have in trunk, it seemed preferable to restore it.

review: Needs Resubmitting

[Nathan Williams (nwilliams)]

A static final end for the two magic values (12345 and _temporary_volume) would be nice. Coming across that in the future could be confusing otherwise.

Now that tree handles are always loaded proactively, it might be nice to make JournalManage#handleForTree() private/package, grab the current handle in usages in Transaction, and assert in the various JournalManager#write* methods that the incoming handling is non-0.

I don't mean to harp, but since we are trying to fix a bug about the handle lifetime it seems preferable to check all of our assumptions related to it.

review: Needs Fixing

[lp:~pbeaman/akiban-persistit/fix_1018526_temp_trees_in_journal]

335. By Peter Beaman on 2012-06-29

Changes per Nathan's review

[Peter Beaman (pbeaman)]

Modified as requested.

review: Needs Resubmitting

[Nathan Williams (nwilliams)]

I don't mean to nitpick, but the other source of the constants is in Persistit#createTemporaryVolume(). It is minor, but I know *I* will forget about this soon and it would be easy for one to change and not the other.

Feel free to self-approve after that tiny change.

review: Needs Fixing

[lp:~pbeaman/akiban-persistit/fix_1018526_temp_trees_in_journal]

336. By Peter Beaman on 2012-06-30

Use constants when creating temp volume

[Peter Beaman (pbeaman)]

Good suggestion. Delegated createTemporaryVolume to a static method in the Volume class to keep the constants private.

=== modified file 'src/main/java/com/persistit/Buffer.java'
--- src/main/java/com/persistit/Buffer.java	2012-06-29 20:54:00 +0000
+++ src/main/java/com/persistit/Buffer.java	2012-06-30 15:14:20 +0000
@@ -3712,8 +3712,10 @@
             if (p == KEY_BLOCK_START) {
                 if (tree != null) {
                     if (!_enqueuedForAntiValuePruning) {
+                        final int treeHandle = tree.getHandle();
+                        assert treeHandle != 0 : "MVV found in a temporary tree " + tree;
                         if (_persistit.getCleanupManager().offer(
-                                new CleanupAntiValue(tree.getHandle(), getPageAddress()))) {
+                                new CleanupAntiValue(treeHandle, getPageAddress()))) {
                             _enqueuedForAntiValuePruning = true;
                         }
                     }

=== modified file 'src/main/java/com/persistit/Exchange.java'
--- src/main/java/com/persistit/Exchange.java	2012-06-29 20:54:00 +0000
+++ src/main/java/com/persistit/Exchange.java	2012-06-30 15:14:20 +0000
@@ -2777,7 +2777,9 @@
             fetchFixupForLongRecords(value, Integer.MAX_VALUE);
             if (MVV.isArrayMVV(value.getEncodedBytes(), 0, value.getEncodedSize())) {
                 if (bufferForPruning != null) {
-                    bufferForPruning.enqueuePruningAction(_tree.getHandle());
+                    final int treeHandle = _tree.getHandle();
+                    assert treeHandle != 0 : "MVV found in a temporary tree " + _tree;
+                    bufferForPruning.enqueuePruningAction(treeHandle);
                 }
                 visible = mvccFetch(value, minimumBytes);
                 fetchFixupForLongRecords(value, minimumBytes);

=== modified file 'src/main/java/com/persistit/IntegrityCheck.java'
--- src/main/java/com/persistit/IntegrityCheck.java	2012-06-28 20:08:30 +0000
+++ src/main/java/com/persistit/IntegrityCheck.java	2012-06-30 15:14:20 +0000
@@ -833,9 +833,9 @@
                 }
                 _currentTree = null;
             }
-            if (_holes.size() > 0) {
-                postMessage("  Tree " + resourceName(tree) + " has " + plural(_holes.size(), "unindexed page"),
-                        LOG_NORMAL);
+            if (_counters._indexHoleCount > 0) {
+                postMessage("  Tree " + resourceName(tree) + " has "
+                        + plural((int) _counters._indexHoleCount, "unindexed page"), LOG_NORMAL);
                 if (_fixHoles) {
                     int offered = 0;
                     for (final CleanupIndexHole hole : _holes) {
@@ -1082,7 +1082,8 @@
                 }
 
                 _counters._indexHoleCount++;
-                if (_holes.size() < MAX_HOLES_TO_FIX) {
+                final int treeHandle = _currentTree.getHandle();
+                if (treeHandle != 0 && _holes.size() < MAX_HOLES_TO_FIX) {
                     _holes.add(new CleanupIndexHole(_currentTree.getHandle(), page, level));
                 }
 

=== modified file 'src/main/java/com/persistit/JournalManager.java'
--- src/main/java/com/persistit/JournalManager.java	2012-06-22 19:07:13 +0000
+++ src/main/java/com/persistit/JournalManager.java	2012-06-30 15:14:20 +0000
@@ -213,6 +213,8 @@
 
     private volatile long _earliestAbortedTimestamp = Long.MAX_VALUE;
 
+    private boolean _allowHandlesForTempVolumesAndTrees;
+
     /**
      * <p>
      * Initialize the new journal. This method takes its information from the
@@ -540,7 +542,10 @@
         return Math.min(urgency, URGENT);
     }
 
-    public int handleForVolume(final Volume volume) throws PersistitException {
+    int handleForVolume(final Volume volume) throws PersistitException {
+        if (!_allowHandlesForTempVolumesAndTrees && volume.isTemporary()) {
+            throw new IllegalStateException("Creating handle for temporary volume " + volume);
+        }
         if (volume.getHandle() != 0) {
             return volume.getHandle();
         }
@@ -580,6 +585,9 @@
     }
 
     int handleForTree(final Tree tree) throws PersistitException {
+        if (!_allowHandlesForTempVolumesAndTrees && tree.getVolume().isTemporary()) {
+            throw new IllegalStateException("Creating handle for temporary tree " + tree);
+        }
         if (tree.getHandle() != 0) {
             return tree.getHandle();
         }
@@ -2835,6 +2843,10 @@
         return files;
     }
 
+    void unitTestAllowHandlesForTemporaryVolumesAndTrees() {
+        _allowHandlesForTempVolumesAndTrees = true;
+    }
+
     public PageNode queryPageNode(final int volumeHandle, final long pageAddress) {
         PageNode pn = _pageMap.get(new PageNode(volumeHandle, pageAddress, -1, -1));
         if (pn != null) {

=== modified file 'src/main/java/com/persistit/Persistit.java'
--- src/main/java/com/persistit/Persistit.java	2012-06-22 19:35:13 +0000
+++ src/main/java/com/persistit/Persistit.java	2012-06-30 15:14:20 +0000
@@ -1108,7 +1108,7 @@
      * <p />
      * The backing store file for a temporary volume is created in the directory
      * specified by the configuration property <code>tmpvoldir</code>, or if
-     * unspecified, the system temporary directory..
+     * unspecified, the system temporary directory.
      * 
      * @param pageSize
      *            The page size for the volume. Must be one of 1024, 2048, 4096,
@@ -1121,9 +1121,7 @@
         if (!Volume.isValidPageSize(pageSize)) {
             throw new IllegalArgumentException("Invalid page size " + pageSize);
         }
-        Volume volume = new Volume(Thread.currentThread().getName() + "_temporary_volume", 12345);
-        volume.openTemporary(this, pageSize);
-        return volume;
+        return Volume.createTemporaryVolume(this, pageSize);
     }
 
     /**

=== modified file 'src/main/java/com/persistit/RecoveryManager.java'
--- src/main/java/com/persistit/RecoveryManager.java	2012-06-14 20:15:48 +0000
+++ src/main/java/com/persistit/RecoveryManager.java	2012-06-30 15:14:20 +0000
@@ -595,8 +595,13 @@
 
     void collectRecoveredVolumeMaps(final Map<Integer, Volume> handleToVolumeMap,
             final Map<Volume, Integer> volumeToHandleMap) {
-        volumeToHandleMap.putAll(_volumeToHandleMap);
-        handleToVolumeMap.putAll(_handleToVolumeMap);
+        for (final Map.Entry<Integer, Volume> entry : _handleToVolumeMap.entrySet()) {
+            final Volume volume = entry.getValue();
+            if (!volume.isTemporary()) {
+                volumeToHandleMap.put(volume, entry.getKey());
+                handleToVolumeMap.put(entry.getKey(), volume);
+            }
+        }
     }
 
     void collectRecoveredTreeMaps(final Map<Integer, TreeDescriptor> handleToTreeMap,
@@ -994,10 +999,17 @@
         final Integer handle = Integer.valueOf(IT.getHandle(_readBuffer));
         final String treeName = IT.getTreeName(_readBuffer);
         final Integer volumeHandle = Integer.valueOf(IT.getVolumeHandle(_readBuffer));
-        final TreeDescriptor td = new TreeDescriptor(volumeHandle, treeName);
-        _handleToTreeMap.put(handle, td);
-        _treeToHandleMap.put(td, handle);
-        _persistit.getLogBase().recoveryRecord.log("IT", addressToString(address, timestamp), treeName, timestamp);
+        final Volume volume = _handleToVolumeMap.get(volumeHandle);
+        if (volume == null) {
+            throw new CorruptJournalException("IT JournalRecord refers to unidentified volume handle " + volumeHandle
+                    + " at position " + addressToString(address, timestamp));
+        }
+        if (!volume.isTemporary()) {
+            final TreeDescriptor td = new TreeDescriptor(volumeHandle, treeName);
+            _handleToTreeMap.put(handle, td);
+            _treeToHandleMap.put(td, handle);
+            _persistit.getLogBase().recoveryRecord.log("IT", addressToString(address, timestamp), treeName, timestamp);
+        }
     }
 
     /**

=== modified file 'src/main/java/com/persistit/Transaction.java'
--- src/main/java/com/persistit/Transaction.java	2012-05-25 18:50:59 +0000
+++ src/main/java/com/persistit/Transaction.java	2012-06-30 15:14:20 +0000
@@ -1097,8 +1097,7 @@
     void store(Exchange exchange, Key key, Value value) throws PersistitException {
         if (_nestedDepth > 0) {
             checkPendingRollback();
-            final int treeHandle = _persistit.getJournalManager().handleForTree(exchange.getTree());
-            writeStoreRecordToJournal(treeHandle, key, value);
+            writeStoreRecordToJournal(treeHandle(exchange.getTree()), key, value);
         }
     }
 
@@ -1113,8 +1112,7 @@
     void remove(Exchange exchange, Key key1, Key key2) throws PersistitException {
         if (_nestedDepth > 0) {
             checkPendingRollback();
-            final int treeHandle = _persistit.getJournalManager().handleForTree(exchange.getTree());
-            writeDeleteRecordToJournal(treeHandle, key1, key2);
+            writeDeleteRecordToJournal(treeHandle(exchange.getTree()), key1, key2);
         }
     }
 
@@ -1127,8 +1125,7 @@
     void removeTree(Exchange exchange) throws PersistitException {
         if (_nestedDepth > 0) {
             checkPendingRollback();
-            final int treeHandle = _persistit.getJournalManager().handleForTree(exchange.getTree());
-            writeDeleteTreeToJournal(treeHandle);
+            writeDeleteTreeToJournal(treeHandle(exchange.getTree()));
         }
     }
 
@@ -1203,7 +1200,7 @@
     }
 
     synchronized void writeDeltaToJournal(final Delta delta) throws PersistitException {
-        final int treeHandle = _persistit.getJournalManager().handleForTree(delta.getAccumulator().getTree());
+        final int treeHandle = treeHandle(delta.getAccumulator().getTree());
         if (delta.getValue() == 1) {
             prepare(D0.OVERHEAD);
             JournalRecord.putLength(_buffer, D0.OVERHEAD);
@@ -1292,6 +1289,12 @@
                     + MAXIMUM_STEP);
         }
     }
+    
+    private int treeHandle(final Tree tree) {
+        final int treeHandle = tree.getHandle();
+        assert treeHandle != 0 : "Undefined tree handle in " + tree;
+        return treeHandle;
+    }
 
     /**
      * For unit tests only

=== modified file 'src/main/java/com/persistit/Tree.java'
--- src/main/java/com/persistit/Tree.java	2012-05-25 18:50:59 +0000
+++ src/main/java/com/persistit/Tree.java	2012-06-30 15:14:20 +0000
@@ -279,6 +279,17 @@
     }
 
     /**
+     * Assign are set the tree handle. The tree must may not be a member of a
+     * temporary volume.
+     * 
+     * @throws PersistitException
+     */
+    void loadHandle() throws PersistitException {
+        assert !_volume.isTemporary() : "Handle allocation for temporary tree " + this;
+        _persistit.getJournalManager().handleForTree(this);
+    }
+
+    /**
      * Return an <code>Accumulator</code> for this Tree. The caller provides the
      * type (SUM, MAX, MIN or SEQ) of accumulator, and an index value between 0
      * and 63, inclusive. If the <code>Tree</code> does not yet have an

=== modified file 'src/main/java/com/persistit/Volume.java'
--- src/main/java/com/persistit/Volume.java	2012-06-15 14:26:11 +0000
+++ src/main/java/com/persistit/Volume.java	2012-06-30 15:14:20 +0000
@@ -62,6 +62,16 @@
     private volatile VolumeStatistics _statistics;
     private volatile VolumeStructure _structure;
 
+    /*
+     * These two constants are used to identify temporary volumes that may have
+     * been identified in existing journal files due to bug 1018526. They are
+     * used in code to detect and remove these records. Once all existing
+     * Persistit volumes sites have been cleaned up, we can remove these
+     * constants and the logic that depends on them.
+     */
+    private final static long TEMP_VOLUME_ID_FOR_FIXUP_DETECTION = 12345;
+    private final static String TEMP_VOLUME_NAME_SUFFIX_FOR_FIXUP_DETECTION = "_temporary_volume";
+
     public static boolean isValidPageSize(final int pageSize) {
         for (int b = 1024; b <= 16384; b *= 2) {
             if (b == pageSize) {
@@ -71,6 +81,13 @@
         return false;
     }
 
+    static Volume createTemporaryVolume(final Persistit persistit, final int pageSize) throws PersistitException {
+        Volume volume = new Volume(Thread.currentThread().getName() + TEMP_VOLUME_NAME_SUFFIX_FOR_FIXUP_DETECTION,
+                TEMP_VOLUME_ID_FOR_FIXUP_DETECTION);
+        volume.openTemporary(persistit, pageSize);
+        return volume;
+    }
+
     /**
      * Construct a hollow Volume - used by JournalManager
      * 
@@ -289,7 +306,15 @@
         return getStructure().getDirectoryTree();
     }
 
-    boolean isTemporary() { // TODO
+    boolean isTemporary() {
+        if (_storage == null) {
+            /*
+             * TODO - Temporary code to detect temporary volumes on existing
+             * systems to resolve side-effects of bug 1018526.
+             */
+            return _id == TEMP_VOLUME_ID_FOR_FIXUP_DETECTION
+                    && _name.endsWith(TEMP_VOLUME_NAME_SUFFIX_FOR_FIXUP_DETECTION);
+        }
         return getStorage().isTemp();
     }
 

=== modified file 'src/main/java/com/persistit/VolumeStructure.java'
--- src/main/java/com/persistit/VolumeStructure.java	2012-06-22 19:07:13 +0000
+++ src/main/java/com/persistit/VolumeStructure.java	2012-06-30 15:14:20 +0000
@@ -79,6 +79,9 @@
             _directoryTree.setRootPageAddress(rootPageAddr);
             updateDirectoryTree(_directoryTree);
         }
+        if (!_volume.isTemporary()) {
+            _directoryTree.loadHandle();
+        }
         _directoryTree.setValid();
     }
 
@@ -188,7 +191,9 @@
         } else {
             return null;
         }
-        _persistit.getJournalManager().handleForTree(tree);
+        if (!_volume.isTemporary()) {
+            tree.loadHandle();
+        }
         _treeNameHashMap.put(name, new WeakReference<Tree>(tree));
         return tree;
     }

=== added file 'src/test/java/com/persistit/Bug1018526Test.java'
--- src/test/java/com/persistit/Bug1018526Test.java	1970-01-01 00:00:00 +0000
+++ src/test/java/com/persistit/Bug1018526Test.java	2012-06-30 15:14:20 +0000
@@ -0,0 +1,104 @@
+/**
+ * Copyright © 2011-2012 Akiban Technologies, Inc.  All rights reserved.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, version 3 (only) of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ * 
+ * This program may also be available under different license terms. For more
+ * information, see www.akiban.com or contact [e-mail].
+ */
+
+package com.persistit;
+
+import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+import org.junit.Test;
+
+import com.persistit.JournalManager.TreeDescriptor;
+import com.persistit.unit.PersistitUnitTestCase;
+
+public class Bug1018526Test extends PersistitUnitTestCase {
+
+    @Test
+    public void tempVolumesAndTreesDoNotGetHandles() throws Exception {
+        final Volume volume = _persistit.createTemporaryVolume();
+        final Exchange exchange = _persistit.getExchange(volume, "a_temp_tree", true);
+        assertEquals("Handle should be 0", 0, volume.getHandle());
+        assertEquals("Handle should be 0", 0, exchange.getTree().getHandle());
+    }
+
+    @Test
+    public void txnOnTempVolumeDoesNotWriteToJournal() throws Exception {
+        final Transaction txn = _persistit.getTransaction();
+        final JournalManager jman = _persistit.getJournalManager();
+        int failed = 0;
+        for (int i = 0; i < 10; i++) {
+            final long startingAddress = jman.getCurrentAddress();
+            txn.begin();
+            try {
+                final Volume volume = _persistit.createTemporaryVolume();
+                final Exchange exchange = _persistit.getExchange(volume, "a_temp_tree", true);
+                exchange.clear().append("abc");
+                exchange.getValue().put(RED_FOX);
+                exchange.store();
+                txn.commit();
+                if (jman.getCurrentAddress() != startingAddress) {
+                    failed++;
+                }
+            } finally {
+                txn.end();
+            }
+        }
+        /*
+         * Don't require 0 because a checkpoint could write to the journal in a race
+         */
+        assertTrue("Transaction on temporary volume should not have written to journal", failed < 3);
+    }
+    
+    @Test
+    public void temporaryVolumesAndTreesNotReloaded() throws Exception {
+        final Set<Integer> permTreeHandleSet = new HashSet<Integer>();
+        final Volume permVolume = _persistit.getVolume("persistit");
+        _persistit.getJournalManager().unitTestAllowHandlesForTemporaryVolumesAndTrees();
+        for (int i = 0; i < 20; i++) {
+            final Volume tempVolume = _persistit.createTemporaryVolume();
+            for (int j = 0; j < 10; j++) {
+                final Tree tempTree = tempVolume.getTree("temp_tree_" + i + "_" + j, true);
+                _persistit.getJournalManager().handleForTree(tempTree);
+                final Tree permTree= permVolume.getTree("perm_tree_" + i + "_" + j, true);
+                _persistit.getJournalManager().handleForTree(permTree);
+                if (!permTreeHandleSet.add(permTree.getHandle())) {
+                    fail("Duplicate tree handle " + permTree.getHandle() + " for " + permTree);
+                }
+            }
+        }
+        final Configuration cfg = _persistit.getConfiguration();
+        _persistit.close();
+        _persistit = new Persistit();
+        _persistit.initialize(cfg);
+        Map<Integer, TreeDescriptor> map = _persistit.getJournalManager().queryTreeMap();
+        for (Integer handle : permTreeHandleSet) {
+            TreeDescriptor td = map.remove(handle);
+            assertNotNull("Permanent Tree should be un the tree map", td);
+        }
+        // expect 1: the directory tree
+        assertEquals("Recovered tree map should contain only permanent trees", 1, map.size());
+    }
+}

=== modified file 'src/test/java/com/persistit/Bug932097Test.java'
--- src/test/java/com/persistit/Bug932097Test.java	2012-05-25 18:50:59 +0000
+++ src/test/java/com/persistit/Bug932097Test.java	2012-06-30 15:14:20 +0000
@@ -24,9 +24,6 @@
 
 import org.junit.Test;
 
-import com.persistit.Exchange;
-import com.persistit.Persistit;
-import com.persistit.Transaction;
 import com.persistit.unit.PersistitUnitTestCase;
 
 public class Bug932097Test extends PersistitUnitTestCase {