Merge lp:~pbeaman/akiban-persistit/release-3.1.7-prep into lp:akiban-persistit

[Peter Beaman]

Updated release notes:
- reformatted to be more concise and readable
- added new bugs and changes for version 3.1.7.
- added code in documentation preparation classes to create the bug list table

Applied code-cleanup rules (mostly adding "final" to a number of declarations) for consistency.

LBJ: NO_BUILD

[lp:~pbeaman/akiban-persistit/release-3.1.7-prep]

367. By Peter Beaman on 2012-09-11

Typo in SphinxDocPrep.java

368. By Peter Beaman on 2012-09-11

Add the BugList file

[Peter Beaman (pbeaman)]

Self-approving because there are no code changes (other than cosmetic changes) and Nathan is unavailable to review.

review: Approve

=== added file 'doc/BugList'
--- doc/BugList	1970-01-01 00:00:00 +0000
+++ doc/BugList	2012-09-11 21:38:18 +0000
@@ -0,0 +1,145 @@
+1044513 : 3.1.7
+
+`AssertionError in IntegrityCheckTest`
+
+A bug in unit test code caused spurious assertion errors.
+
+1044397 : 3.1.7
+
+`IntegrityCheck throws ArrayIndexOutOfBoundsException`
+
+IntegrityCheck and the CLI ``pview`` command were not immune to
+certain inconsistent byte patterns in a corrupt page, making them
+inadequate for diagnosing a severely corrupted database.
+
+1041293 : 3.1.7
+
+`Mismatched buffer pool sizes and volume page size results in NPE`
+
+Attempting to open a Volume with a valid page size S resulted in a
+NullPointerException if there was no buffer pool having page size
+S specified. This same condition how throws an IllegalStateException.
+
+1043536 : 3.1.7
+
+`Build fails: persistit-coverage hangs with deadlock`
+
+A bug in a unit test left a deadlock condition under certain race
+conditions. Speed variations caused by clover instrumentation
+triggered frequent occurrences.
+
+1036422 : 3.1.6
+
+`CommitPolicy HARD can soak CPU`
+
+With CommitPolicy HARD we observed a CPU-soaking loop in the commit
+logic.
+
+1032701 : 3.1.5
+
+`Interrupt causes Thread to exit without releasing claims`
+
+If a thread was interrupted at an inopportune time (for example,
+by query cancellation in Akiban Server), a page in the buffer pool
+could be left in a locked state blocking all further progress. The
+only remedy was to stop and restart the JVM.
+
+1028016 : 3.1.4
+
+`Old Journal Files Not Being Deleted`
+
+If a volume was removed from the configuration and Persistit was
+then restarted, the associated journal files would not be removed
+due to internal safety checks. To support intentional removal of a
+volume, a new configuration option was added.
+
+See the ``Detecting and Ignoring Missing Volumes`` feature description
+for more details.
+
+
+1024857,1026207 : 3.1.4
+
+`Class Index Updates Causing Write-Write Dependencies`
+
+Custom classes that are serialized into keys or values through a
+custom KeyCoder or ValueCoder are given a unique identifier.  The
+identifier was determined within an application transaction the
+first time a class was written and stored in an internal tree.  This
+would cause seemingly spurious aborts if multiple application threads
+simultaneously attempted to store the first instance of a given
+class. The identifier is now committed within an independent
+transaction.
+
+1028050,1028134 : 3.1.4
+
+`Accumulator Memory Usage and Transaction Step Policy`
+
+Each individual change to an Accumulator was previously stored as
+an individual Delta object. For long running transactions that
+heavily utilized Accumulators, this would cause excessive memory
+usage. These unique instances are now eliminated in most scenarios,
+resulting in stable memory utilization in all but pathological
+cases.
+
+Additionally, the Accumulator handling of the Transaction step value
+was inconsistent with how it was treated through an Exchange.  Now,
+both classes allow a transaction at a given step N to see any update
+created by that transaction at a step less N.
+
+
+1005206 : 3.1.2
+
+`Infinite Loop When Repacking Buffer`
+
+This could occur if a buffer required restructuring during pruning
+of a long value that was previously stored under a transaction.
+Upon the next save of this buffer to disk (e.g.  shutdown), an
+infinite loop would occur.
+
+
+1010079 : 3.1.2
+
+`Corruption Exceptions During Various Operations`
+
+NOTE: Only the message indicates a database corruption. The data
+volume is actually correct and intact.
+
+This could occur if pruning a buffer containing a long record
+previously stored under a transaction required removal of keys and
+then that buffer was reused without further modification. A parallel
+structure associated with the every Buffer, the FastIndex, was not
+maintained during this operation.
+
+1012856 : 3.1.2
+
+`Slow Accumulator Operations`
+
+If a thread starting a new transaction was interrupted during the
+call to begin(), there was a chance for an internal object to wind
+up in an invalid state. This invalid state caused no visible
+consequences other than slower than expected Accumulator actions
+if this had occurred many times.
+
+
+1017957 : 3.1.2
+
+`B+Tree Corruption in Stress Test`
+
+An extremely rare combination of events corrupted memory structures
+causing an incorrect key-pointer pair to be inserted while deleting
+records in a key range. The bug was detected in an 8-hour stress
+test run.
+
+1018526 : 3.1.2
+
+`Very long recovery time due to many temporary tree IT records`
+
+Every Tree created in a temporary volume was being assigned a tree
+handle recorded permanently in the journal.  In one case the result
+was a journal containing millions of IT (Identify Tree) records,
+and these caused normal recovery to take a very long time. The fix
+keeps temporary trees out of the journal and removes IT records
+which may have been added previously.
+
+
+
 
=== modified file 'doc/Configuration.rst'
--- doc/Configuration.rst	2012-08-23 21:10:56 +0000
+++ doc/Configuration.rst	2012-09-11 21:38:18 +0000
@@ -185,7 +185,24 @@
 
 The journal is written by appending records to the end of the highest-numbered file. Read operations occur while copying page images from the journal to their home volume files. While copying, Persistit attempts to perform large sequential read operations from the journal. Read operations also occur at random when Persistit needs to reload the image of a previously evicted page.
 
-Because of these characteristics a modern SSD (solid disk drive) is ideally suited for maintaining the journal. If no SSD is available in the server, placing the journal on a different physical disk drive than the volume file(s) can significantly improve performance.
+Because of these characteristics a modern enterprise SSD (solid disk drive) is ideally suited for maintaining the journal. If no SSD is available in the server, placing the journal on a different physical disk drive than the volume file(s) can significantly improve performance.
+
+However, beware of consumer-grade SSDs. Some may cache writes and record them on non-volatile storage much later. In a power failure event, committed transactions recorded only in the write cache can be lost. The durability of committed transactions can only be guaranteed if the hardware stack cooperates in making sure all writes are durable.
+
+Buffer Pool Preload
+-------------------
+
+Persistit includes an optional facility to record periodically an inventory of pages in the buffer pool. When Persistit starts up it attempts to re-read the same pages that were previously in the buffer pool so that performance after restart on a similar workload (e.g., queries that exhibit a moderate or strong degree of locality-of-reference) will run at full speed. This facility can be especially important in large buffer pool configurations in which under normal workloads a server may otherwise require minutes to hours to reach optimal speed due to a large number of random reads. Re-reading the inventory at startup can be much faster since pages are read in approximate physical order.
+
+This facility is controlled by two configuration parameters:
+
+- ``com.persistit.Configuration#setBufferInventoryEnabled`` controls whether Persistit records the inventory. If enabled, the recording happens once per Checkpoint and once at normal shutdown.  The inventory is stored in the system volume.
+
+- ``com.persistit.Configuration#setBufferPreloadEnabled`` controls whether Persistit attempts to preload the buffer pool during startup. If there is a recorded inventory Persistit attempts to re-read the pages that were previously present; otherwise it silently continues the startup.
+
+If upon restart the buffer pool has become smaller so that the inventory is larger than the current buffer pool, Persistit only loads as many pages as there currently are buffers.
+
+Although by default these configuration properties are false, we recommend enabling them for production servers because the inventory process takes very little time, and buffer preload can restore the buffer pool to a useful working set orders of magnitude faster than warming it up through normal load.
 
 Other Configuration Parameters
 ------------------------------
@@ -232,14 +249,14 @@
       only when no adapter has been installed.
 
   ``bufferinventory``: (``com.persistit.Configuration#setBufferInventoryEnabled``), True or False (default).
-      If true, Persistit periodically records an inventory of all the buffes in the buffers pools to the System Volume. The inventory
+      If true, Persistit periodically records an inventory of all the pages in the buffers pools to the System Volume. The inventory
       enables Persistit to preload the buffer pools then next time it starts up with approximately the same pages that were present
       before shutdown. To enable buffer preloading, the bufferpreload property must also be true.
       
   ``bufferpreload``: (``com.persistit.Configuration#setBufferPreloadEnabled``), True or False (default).
       If true, and if a buffer pool inventory was previously recorded, Persistit attempts to "warm up" the buffer pool
       by preloading pages that were present in the buffer pool when Persistit last shut down. This may allow a freshly started
-      Persistit instance to begin service a workload similar to what it had previously been processing without incurring the
+      Persistit instance to begin servicing a workload similar to what it had previously been handling without incurring the
       cost of many random disk reads to load pages.
         
 
 
=== modified file 'doc/ReleaseNotes.rst'
--- doc/ReleaseNotes.rst	2012-08-24 18:16:21 +0000
+++ doc/ReleaseNotes.rst	2012-09-11 21:38:18 +0000
@@ -44,207 +44,81 @@
 |
 |
 
-
-************************************
-3.1.6
-************************************
-
-Release Date
-============
-August 24, 2012
-
-Overview
-========
-This version of Persistit fixes one bug.
-
-Fixed Issues
-============
-
-https://bugs.launchpad.net/akiban-persistit/+bug/1036422
-
-With CommitPolicy HARD we observed a CPU-soaking loop in the commit logic.
-
-************************************
-3.1.5
-************************************
-
-Release Date
-============
-August 6, 2012
-
-Overview
-========
-This version of Persistit changes the pom.xml to a form compatible with the Maven central repository and includes one bug fix.
-
-Fixed Issue
-===========
-
-https://launchpad.net/akiban-persistit/+bug/1032701
-
-If a thread was interrupted at an inopportune time (for example, by query cancellation in Akiban Server), a page in the buffer pool could be left in a locked state blocking all further progress. The only remedy was to stop and restart the JVM.
-
-|
-|
-
-************************************
-3.1.4
-************************************
-
-Release Date
-============
-August 3, 2012
-
-Overview
-========
-This version of Persistit changes the licensing to Eclipse Public License (EPL) and includes minor enhancements and bug fixes.
-
-New Features
-============
-
-Detection and Ignoring of Missing Volumes
------------------------------------------
-
-Warnings are now issues when a previously existing volume is missing, and an option to allow a system to continue by ignoring pages and transactions in the journal from missing volumes.
-
-Every time Persistit writes a modified page to disk, it does so first to the journal.  During recovery processing, the page images from the journal are analyzed and reinserted into volumes in such a way that all B+Trees are restored to a consistent state. The issue addressed in this change is how Persistit behaves during recovery if it discovers that a volume referred to by a page in the journal no longer exists.
-
-Recognizing that under some circumstances an administrator may indeed wish to remove a volume from an existing Database, this change provides a configurable switch to optionally allow pages from missing volumes to be skipped (with logged warning messages) during recovery processing.  The switch can be enabled by setting the configuration parameter ignoreMissingVolumes to true, see com.persistit.Configuration#setIgnoreMissingViolumes.
-
-
-Reduce KeyCoder Serialized Object Size
---------------------------------------
+Version History
+===============
+
++---------+--------------------+--------------------------------------------------------------------------+
+| Version | Release Date       |  Summary                                                                 |
++=========+====================+==========================================================================+
+| 3.1.7   | September 11, 2012 | Fix several bugs, add buffer pool preload ("warm-up"),                   |
+|         |                    | reformat code base                                                       |
++---------+--------------------+--------------------------------------------------------------------------+
+| 3.1.6   | August 24, 2012    | Fix bug 1036422                                                          |
++---------+--------------------+--------------------------------------------------------------------------+
+| 3.1.5   | August 6, 2012     | Fix bug 1032701, modify pom.xml for Eclipse Juno                         |
++---------+--------------------+--------------------------------------------------------------------------+
+| 3.1.4   | August 3, 2012     | License changed to Eclipse Public License, various other enhancements    |
++---------+--------------------+--------------------------------------------------------------------------+
+| 3.1.2   | July 13, 2012      | Fix several bugs                                                         |
++---------+--------------------+--------------------------------------------------------------------------+
+| 3.1.1   | May 31, 2012       | First open source release of Akiban Persistit                            |
++---------+--------------------+--------------------------------------------------------------------------+
+
+
+Resolved Issues
+===============
+
+{{bug-list}}
+
+Changes and New Features
+========================
+
+Persistit 3.1.7 - Code Base Reformatted
+---------------------------------------
+
+To simplify diffs and improve legibility, the entire code base was reformatted and "cleaned up" by the Eclipse code formatting tool. The maven build now automatically formats all
+source to ensure coherent diffs in the future.  The settings for formatting and code style cleanup by Eclipse are found in the ``src/etc`` directory.
+
+Persistit 3.1.7 - Buffer Pool Preload
+-------------------------------------
+
+On a server with a large buffer pool (many gigabytes), a Persistit instance can run for a long time before the buffer pool becomes populated with a suitable working set of database pages. Until then performance is degraded due to a potentially large number of random reads. For a production server the result may be poor performance for minutes to hours after restart.
+
+The preload facility periodically records an inventory of the pages currently in the buffer pool(s) and optionally reloads the same set of pages when Persistit is restarted. During the preload process Persistit attempts to read pages in approximate file-address order to accelerate reads. In one of our experiments Persistit preloads a buffer pool with over 800,000 16Kbyte buffers in about a minute, which is orders of magnitude faster than the same process would take with reads performed incrementally at random.
+
+Two new configuration properties com.persistit.Configuration#setBufferInventoryEnabled and com.persistit#setBufferPreloadEnabled control this behavior. These settings are turned off by default in version 3.1.7.
+
+Persistit 3.1.4 - Detecting and Ignoring Missing Volumes
+--------------------------------------------------------
+
+Every time Persistit writes a modified page to disk, it does so first to the journal. During recovery processing, the page images from the journal are analyzed and reinserted into volumes in such a way that all B+Trees are restored to a consistent state. The issue addressed in this change is how Persistit behaves during recovery if it discovers that a volume referred to by a page in the journal no longer exists.
+
+Recognizing that under some circumstances an administrator may indeed wish to remove a volume from an existing Database, this change provides a configurable switch to optionally allow pages from missing volumes to be skipped (with logged warning messages) during recovery processing.  The switch can be enabled by setting the configuration parameter com.persistit.Configuration#setIgnoreMissingViolumes to true.
+
+
+Persistit 3.1.4 - Reduce KeyCoder Serialized Object Size
+--------------------------------------------------------
 
 .. note::
    Any Database containing objects serialized by a custom KeyCoder from a previous version of Persistit is incompatible with this change
 
 Minimize the per-instance overhead for application objects written into Persistit Keys by reducing the size of the internal identifier.
 
-Persistit has rich support for serializing standard Java primitive and object types into a Key. Additionally, the KeyCoder class allows for any application level object to also be appended to a Key right next to any other type. This is tagged internally with per-class handles. This change lowers the initial offset to, in many cases, halve the serialized size. 
+Persistit has rich support for serializing standard Java primitive and object types into a Key. Additionally, the KeyCoder class allows for any application level object to also be appended to a Key right next to any other type. This is tagged internally with per-class handles. This change lowers the initial offset to reduce and in many cases halve the serialized size. 
 
-Maven POM Changes For Eclipse Juno
-----------------------------------
+Persistit 3.1.4 - Maven POM Changes For Eclipse Juno 
+----------------------------------------------------
 
 The latest version of Eclipse, code named Juno, features a wide array of changes, including a new release of the m2eclipse plugin. In an effort to make getting started with Persistit as easy as possible, we have included the required m2e configuration sections in our pom.
 
 Please contact Akiban if you have encounter any issues getting up and running with Persistit.   
 
-Fixed Issues
-============
-
-Old Journal Files Not Being Deleted
------------------------------------
-
-https://launchpad.net/akiban-persistit/+bug/1028016
-
-If a volume was removed from the configuration and Persistit was restarted the associated journal files would not be removed due to internal safety checks. In the event that the missing volume is intended behavior, a new configuration option was added. See the ``Detection and Ignoring of Missing Volumes`` feature description for more details.
-
-Class Index Updates Causing Write-Write Dependencies
-----------------------------------------------------
-
-https://launchpad.net/akiban-persistit/+bug/1024857
-
-https://launchpad.net/akiban-persistit/+bug/1026207
-
-Custom classes that are serialized into keys or values, through a custom KeyCoder or ValueCoder, are given a unique identifier. The identifier is determined transactionally the first time a class is written and stored in an internal tree. This would cause seemingly spurious aborts if more than one application threads simultaneously attempt to store the first instance of a given class.
-
-Accumulator Memory Usage and Transaction Step Policy
-----------------------------------------------------
-
-https://launchpad.net/akiban-persistit/+bug/1028050
-
-https://launchpad.net/akiban-persistit/+bug/1028134
-
-Changes to Accumulators are stored were previously stored as individual Delta objects. For long running transactions that heavily utilized Accumulators, this would cause excessive memory usage. These unique instances are no eliminated in most scenarios, resulting in no memory growth in all but pathological cases.
-
-Additionally, the Accumulator handling of the Transaction step value was inconsistent with how it was treated through an Exchange. Now, both classes allow a given step x to see any change that occurred at a step less than or equal to itself.
-
-
-Known Issues
-============
-As described in the *3.1.1 Known Issues*.
-
-|
-|
-
-************************************
-3.1.2
-************************************
-
-Release Date
-============
-July 13, 2012
-
-Overview
-========
-This is a bug fix release of the Persistit project (https://launchpad.net/akiban-persistit).  
-
-Fixed Issues
-============
-
-Infinite Loop When Repacking Buffer
------------------------------------
-
-https://bugs.launchpad.net/bugs/1005206
-
-This was introduced late into the 3.1.1 development cycle. This could occur if a buffer required restructuring during pruning of a long value that was previously stored under a transaction. Upon the next save of this buffer to disk (e.g. shutdown), an infinite loop would occur.
-
-Corruption Exceptions During Various Operations
------------------------------------------------
-
-https://bugs.launchpad.net/bugs/1010079
-
-.. note::
-   Only the message indicates a database corruption. The data volume is actually correct and intact.
-
-This was introduced late into the 3.1.1 development cycle. This could occur if pruning a buffer containing a long record previously stored under a transaction required removal of keys and then that buffer was reused without further modification. A parallel structure associated with the every ``Buffer``, the ``FastIndex``, was not maintained during this operation.
-
-Slow Accumulator Operations
----------------------------
-
-https://bugs.launchpad.net/bugs/1012859
-
-This bug preexisted but was unknown to the 3.1.1 release. If a thread starting a new transaction was interrupted during the call to ``begin()``, there was a chance for an internal object to wind up in an invalid state. This invalid state caused no visible consequences other than slower than expected ``Accumulator`` actions if this had occurred many times.
-
-B+Tree Corruption in Stress Test
---------------------------------
-
-https://bugs.launchpad.net/akiban-persistit/+bug/1017957
-
-This bug preexisted but was unknown to the 3.1.1 release. An extremely rare combination of events corrupted memory structures causing an incorrect key-pointer pair to be inserted while deleting records in a key range. The bug was detected in an 8-hour stress test run.
-
-
-Slow Recovery Due to Temporary Tree IT Records
-----------------------------------------------
-
-https://bugs.launchpad.net/akiban-persistit/+bug/1018526
-
-This bug preexisted but was unknown to the 3.1.1 release. Every Tree created in a temporary volume was being assigned a tree handle recorded permanently in the journal. In one case the result was a journal containing millions of IT (Identify Tree) records, and these caused normal recovery to take a very long time.  The fix keeps temporary trees out of the journal and removes IT records which may have been added previously. 
-
-
-Asserts Added to Check for Correct Exchange Thread Behavior
------------------------------------------------------------
+Persistit 3.1.2 - Asserts Added to Check for Correct Exchange Thread Behavior
+-----------------------------------------------------------------------------
 
 A bug in the Akiban Server code caused an Exchange to be used concurrently by two Threads, causing serious and seemingly unrelated failures in Persistit including instances of IllegalMonitorException and IllegalStateException. To guard against future occurrences, asserts were added to catch such concurrent use by multiple threads.  Applications should be tested with asserts enabled to verify correct thread usage.
- 
-
-Known Issues
-============
-As described in the *3.1.1 Known Issues*.
-
-|
-|
-
-************************************
-3.1.1
-************************************
-
-Release Date
-============
-May 31, 2012
-
-Overview
-========
-This is the first open source release of the Persistit project (https://launchpad.net/akiban-persistit).  
+
+
 
 Known Issues
 ============
@@ -283,7 +157,8 @@
 https://bugs.launchpad.net/akiban-persistit/+bug/1000331
 
 Multi-version values are not always pruned properly causing volume growth.  The number of MVV records and their overhead size can be obtaining by running the IntegrityCheck task. 
+
 * Workaround 1: Run the IntegrityCheck task (CLI command icheck) with the -P option which will prune the MVVs. This will remove obsolete MVV instances and in many cases free up pages in which new data can be stored.  However, it will not reduce the actual size of the volume file.
 
-* Workaround 2: To reduce the size of the volume you can use the CLI commands save  and load to offload and then reload the data into a newly created volume file. See http://www.akiban.com/ak-docs/admin/persistit/Management.html#management for more information about these operations.
+* Workaround 2: To reduce the size of the volume you can use the CLI commands ``save`` and ``load`` to reload the data into a newly created volume file. See http://www.akiban.com/ak-docs/admin/persistit/Management.html#management for more information about these operations.
 
 
=== modified file 'doc/build/src/SphinxDocPrep.java'
--- doc/build/src/SphinxDocPrep.java	2012-06-11 21:25:37 +0000
+++ doc/build/src/SphinxDocPrep.java	2012-09-11 21:38:18 +0000
@@ -2,7 +2,10 @@
 import java.io.File;
 import java.io.FileReader;
 import java.io.FileWriter;
+import java.io.IOException;
 import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.List;
 import java.util.SortedMap;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
@@ -68,7 +71,10 @@
     }
 
     private void processLine(final String line) throws Exception {
-        if (line.contains(".. code-block:") || line.endsWith("::")) {
+        if (line.contains("{{bug-list}}")) {
+            prepareBugList();
+            return;
+        } else if (line.contains(".. code-block:") || line.endsWith("::")) {
             block = BlockState.WAIT_FIRST_BLANK_LINE;
         } else if (line.isEmpty()) {
             switch (block) {
@@ -134,14 +140,132 @@
                 text = text.replace("com.persistit.", "");
                 text = text.replace("java.lang.", "");
                 text = text.replace("java.util.", "");
-                replacement= "`" + text + " <" + url + ">`_";
+                replacement = "`" + text + " <" + url + ">`_";
             }
         }
 
         matcher.appendReplacement(sb, Matcher.quoteReplacement(replacement));
     }
 
+    private void prepareBugList() throws IOException {
+        List<String[]> rows = new ArrayList<String[]>();
+        rows.add(new String[] { "Bug Reference", "Fixed in|Version", "Summary" });
+        BufferedReader reader = null;
+        try {
+            String urls = "";
+            String version = "";
+            reader = new BufferedReader(new FileReader("../BugList"));
+            StringBuilder sb = new StringBuilder();
+            String line = null;
+            while ((line = reader.readLine()) != null) {
+                if (line.isEmpty()) {
+                    if (sb.length() > 0) {
+                        sb.append('|');
+                    }
+                } else if (Character.isDigit(line.charAt(0))) {
+                    if (!urls.isEmpty()) {
+                        rows.add(new String[] { urls, version, sb.toString() });
+                        urls = "";
+                        version = "";
+                        sb.setLength(0);
+                    }
+                    String[] split = line.split("\\:");
+                    for (final String bug : split[0].trim().split(",")) {
+                        if (urls.length() > 0) {
+                            urls += '|';
+                        }
+                        urls = urls + "https://launchpad.net/bugs/" + bug;
+                    }
+                    version = split[1].trim();
+                } else {
+                    sb.append(line.trim());
+                    if (sb.length() > 0) {
+                        sb.append('|');
+                    }
+                }
+            }
+            if (!urls.isEmpty()) {
+                rows.add(new String[] { urls, version, sb.toString() });
+            }
+
+            int[] maxWidth = new int[3];
+            for (final String[] row : rows) {
+                for (int i = 0; i < 3; i++) {
+                    for (String s : row[i].split("\\|")) {
+                        maxWidth[i] = Math.max(s.length(), maxWidth[i]);
+                    }
+                }
+            }
+
+            bugTableLine(sb, false, maxWidth);
+            for (int l = 0;; l++) {
+                if (bugTableText(sb, rows.get(0), maxWidth, l)) {
+                    break;
+                }
+            }
+            bugTableLine(sb, true, maxWidth);
+            for (int i = 1; i < rows.size(); i++) {
+                String[] text = rows.get(i);
+                for (int l = 0;; l++) {
+                    if (bugTableText(sb, text, maxWidth, l)) {
+                        break;
+                    }
+                }
+                bugTableLine(sb, false, maxWidth);
+            }
+        } catch (IOException e) {
+            System.out.println(e + " while trying to read BugList");
+        } finally {
+            if (reader != null) {
+                reader.close();
+            }
+        }
+    }
+
+    private void bugTableLine(StringBuilder sb, boolean dline, int[] width) {
+        sb.setLength(0);
+        sb.append('+');
+        for (int j = 0; j < 3; j++) {
+            for (int i = 0; i < width[j] + 2; i++) {
+                sb.append(dline ? '=' : '-');
+            }
+            sb.append('+');
+        }
+        writer.println(sb);
+        writer.flush();
+    }
+
+    private boolean bugTableText(StringBuilder sb, String[] text, int[] width, int line) {
+        String[] s = new String[3];
+        boolean done = true;
+        for (int j = 0; j < 3; j++) {
+            String[] split = text[j].split("\\|");
+            if (split.length > line) {
+                done = false;
+                s[j] = split[line];
+            }
+        }
+        if (!done) {
+            sb.setLength(0);
+            sb.append("|");
+            for (int j = 0; j < 3; j++) {
+                if (s[j] == null) {
+                    s[j] = "";
+                }
+                sb.append(' ');
+                sb.append(s[j]);
+                for (int i = s[j].length() + 1; i < width[j] + 2; i++) {
+                    sb.append(' ');
+                }
+                sb.append('|');
+            }
+            writer.println(sb);
+        }
+        writer.flush();
+        return done;
+    }
+
     public static void main(final String[] args) throws Exception {
-        new SphinxDocPrep().prepare(args);
+         new SphinxDocPrep().prepare(args);
     }
 }
 
=== modified file 'src/main/java/com/persistit/IntegrityCheck.java'
--- src/main/java/com/persistit/IntegrityCheck.java	2012-08-31 14:06:47 +0000
+++ src/main/java/com/persistit/IntegrityCheck.java	2012-09-11 21:38:18 +0000
@@ -1158,7 +1158,7 @@
                     }
                 }
             }
-        } catch (Exception e) {
+        } catch (final Exception e) {
             addFault(e.toString(), page, level, 0);
         }
         return true;
@@ -1213,7 +1213,7 @@
 
                 fromPage = longPage;
                 longPage = longBuffer.getRightSibling();
-            } catch (Exception e) {
+            } catch (final Exception e) {
                 addFault(e.toString() + " while verifying long record page " + longPage, page, 0, foundAt);
                 break;
             } finally {
 
=== modified file 'src/main/java/com/persistit/JournalManager.java'
--- src/main/java/com/persistit/JournalManager.java	2012-08-28 16:15:27 +0000
+++ src/main/java/com/persistit/JournalManager.java	2012-09-11 21:38:18 +0000
@@ -29,7 +29,6 @@
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.HashMap;
-import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 
=== modified file 'src/main/java/com/persistit/JournalManagerBench.java'
--- src/main/java/com/persistit/JournalManagerBench.java	2012-08-20 19:24:58 +0000
+++ src/main/java/com/persistit/JournalManagerBench.java	2012-09-11 21:38:18 +0000
@@ -123,7 +123,7 @@
                 }
                 if (remaining > buffer.capacity()) {
                     remaining = buffer.capacity();
-                    long unaligned = fc.size() % 16384;
+                    final long unaligned = fc.size() % 16384;
                     if (unaligned > 0) {
                         remaining = remaining - (16384 - unaligned);
                     }
@@ -139,12 +139,12 @@
 
     private void doOneCycle(final long time, final int align, final long extension, final int size) throws Exception {
         // Make a fake transaction record
-        String header = String.format("\nsize=%06d count=%06d time=%012d\n", size, count, time);
-        byte[] b = header.getBytes();
+        final String header = String.format("\nsize=%06d count=%06d time=%012d\n", size, count, time);
+        final byte[] b = header.getBytes();
         System.arraycopy(b, 0, bytes, 0, b.length);
 
         // Add the record, possibly offset to maintaining alignment
-        int toRewrite = (int) (currentAddress - writeAddress);
+        final int toRewrite = (int) (currentAddress - writeAddress);
         buffer.position(toRewrite);
         buffer.put(bytes, 0, size);
         boolean extended = false;
 
=== modified file 'src/main/java/com/persistit/Persistit.java'
--- src/main/java/com/persistit/Persistit.java	2012-08-31 20:20:13 +0000
+++ src/main/java/com/persistit/Persistit.java	2012-09-11 21:38:18 +0000
@@ -725,7 +725,7 @@
             for (final BufferPool pool : _bufferPoolTable.values()) {
                 try {
                     pool.recordBufferInventory(timestamp);
-                } catch (PersistitException e) {
+                } catch (final PersistitException e) {
                     getLogBase().bufferInventoryException.log(e);
                 }
             }
 
=== modified file 'src/test/java/com/persistit/Bug1041293Test.java'
--- src/test/java/com/persistit/Bug1041293Test.java	2012-09-04 21:01:23 +0000
+++ src/test/java/com/persistit/Bug1041293Test.java	2012-09-11 21:38:18 +0000
@@ -34,7 +34,7 @@
         final Configuration config = _persistit.getConfiguration();
         final VolumeSpecification vspec = config.volumeSpecification("${datapath}/test,pageSize:2048,create,"
                 + "initialPages:100,extensionPages:100,maximumPages:25000");
-        Volume volume = _persistit.loadVolume(vspec);
+        final Volume volume = _persistit.loadVolume(vspec);
         volume.open(_persistit);
     }
 
 
=== modified file 'src/test/java/com/persistit/TrackingFileChannel.java'
--- src/test/java/com/persistit/TrackingFileChannel.java	2012-08-27 17:31:02 +0000
+++ src/test/java/com/persistit/TrackingFileChannel.java	2012-09-11 21:38:18 +0000
@@ -15,9 +15,8 @@
 
 package com.persistit;
 
-import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+
 import java.io.IOException;
 import java.nio.ByteBuffer;
 import java.nio.MappedByteBuffer;
@@ -161,9 +160,9 @@
         return _readPositions;
     }
 
-    public void assertOrdered(boolean read, boolean forward) {
+    public void assertOrdered(final boolean read, final boolean forward) {
         final List<Long> list = read ? _readPositions : _writePositions;
-        long previous = forward ? -1 : Long.MAX_VALUE;
+        final long previous = forward ? -1 : Long.MAX_VALUE;
         for (final Long position : list) {
             if (forward) {
                 assertTrue("Position should be larger", position > previous);
 
=== modified file 'src/test/java/com/persistit/stress/unit/CommitBench.java'
--- src/test/java/com/persistit/stress/unit/CommitBench.java	2012-08-24 13:57:19 +0000
+++ src/test/java/com/persistit/stress/unit/CommitBench.java	2012-09-11 21:38:18 +0000
@@ -85,11 +85,11 @@
                     /*
                      * Damage the file so that there's no keystone checkpoint
                      */
-                    RandomAccessFile raf = new RandomAccessFile(file, "rws");
+                    final RandomAccessFile raf = new RandomAccessFile(file, "rws");
                     raf.seek(0);
                     raf.write(new byte[256]);
                     raf.close();
-                } catch (IOException e) {
+                } catch (final IOException e) {
                     throw new RuntimeException(e);
                 }
             } else {