JAVA-682: Added new constants for WriteConcern so transition away from 'safe'

Author: jyemin

src/main/com/mongodb/WriteConcern.java

@@ -52,6 +52,11 @@ public class WriteConcern implements Serializable {
 
     private static final long serialVersionUID = 1884671104750417011L;
 
+    /**
+     * No exceptions are raised, even for network issues.
+     */
+    public final static WriteConcern ERRORS_IGNORED = new WriteConcern(-1);
+
     /**
      * Write operations that use this write concern will wait for acknowledgement from the primary server before returning.
      * Exceptions are raised for network issues, and server errors.
@@ -65,8 +70,28 @@ public class WriteConcern implements Serializable {
      */
     public final static WriteConcern UNACKNOWLEDGED = new WriteConcern(0);
 
+    /**
+     * Exceptions are raised for network issues, and server errors; the write operation waits for the server to flush
+     * the data to disk.
+     */
+    public final static WriteConcern FSYNCED = new WriteConcern(true);
+
+    /**
+     * Exceptions are raised for network issues, and server errors; the write operation waits for the server to
+     * group commit to the journal file on disk.
+     */
+    public final static WriteConcern JOURNALED = new WriteConcern( 1, 0, false, true );
+
+    /**
+     * Exceptions are raised for network issues, and server errors; waits for at least 2 servers for the write operation.
+     */
+    public final static WriteConcern REPLICA_ACKNOWLEDGED= new WriteConcern(2);
+
     /**
      * No exceptions are raised, even for network issues.
+     * <p>
+     * This field has been superseded by {@code WriteConcern.ERRORS_IGNORED}, and may be deprecated in a future release.
+     * @see WriteConcern#ERRORS_IGNORED
      */
     public final static WriteConcern NONE = new WriteConcern(-1);
 
@@ -96,17 +121,26 @@ public class WriteConcern implements Serializable {
     /**
      * Exceptions are raised for network issues, and server errors; the write operation waits for the server to flush
      * the data to disk.
+     * <p>
+     * This field has been superseded by {@code WriteConcern.FSYNCED}, and may be deprecated in a future release.
+     * @see WriteConcern#FSYNCED
      */
     public final static WriteConcern FSYNC_SAFE = new WriteConcern(true);
 
     /**
      * Exceptions are raised for network issues, and server errors; the write operation waits for the server to
      * group commit to the journal file on disk.
+     * <p>
+     * This field has been superseded by {@code WriteConcern.JOURNALED}, and may be deprecated in a future release.
+     * @see WriteConcern#JOURNALED
      */
     public final static WriteConcern JOURNAL_SAFE = new WriteConcern( 1, 0, false, true );
 
     /**
      * Exceptions are raised for network issues, and server errors; waits for at least 2 servers for the write operation.
+     * <p>
+     * This field has been superseded by {@code WriteConcern.REPLICA_ACKNOWLEDGED}, and may be deprecated in a future release.
+     * @see WriteConcern#REPLICA_ACKNOWLEDGED
      */
     public final static WriteConcern REPLICAS_SAFE = new WriteConcern(2);
 

src/test/com/mongodb/WriteConcernTest.java

@@ -88,6 +88,10 @@ public void testCheckLastError() {
         Assert.assertTrue(WriteConcern.ACKNOWLEDGED.callGetLastError());
         Assert.assertTrue(WriteConcern.FSYNC_SAFE.callGetLastError());
         Assert.assertTrue(WriteConcern.JOURNAL_SAFE.callGetLastError());
+        Assert.assertFalse(WriteConcern.ERRORS_IGNORED.callGetLastError());
+        Assert.assertTrue(WriteConcern.JOURNALED.callGetLastError());
+        Assert.assertTrue(WriteConcern.FSYNCED.callGetLastError());
+        Assert.assertTrue(WriteConcern.REPLICA_ACKNOWLEDGED.callGetLastError());
         Assert.assertTrue(WriteConcern.MAJORITY.callGetLastError());
         Assert.assertTrue(WriteConcern.REPLICAS_SAFE.callGetLastError());
         Assert.assertTrue(new WriteConcern("custom").callGetLastError());
@@ -96,6 +100,24 @@ public void testCheckLastError() {
         Assert.assertFalse(new WriteConcern(0, 0, false, true).callGetLastError());
     }
 
+    @Test
+    public void testW() {
+        Assert.assertEquals(-1, WriteConcern.NONE.getW());
+        Assert.assertEquals(0, WriteConcern.NORMAL.getW());
+        Assert.assertEquals(0, WriteConcern.UNACKNOWLEDGED.getW());
+        Assert.assertEquals(1, WriteConcern.SAFE.getW());
+        Assert.assertEquals(1, WriteConcern.ACKNOWLEDGED.getW());
+        Assert.assertEquals(1, WriteConcern.FSYNC_SAFE.getW());
+        Assert.assertEquals(1, WriteConcern.JOURNAL_SAFE.getW());
+        Assert.assertEquals(-1, WriteConcern.ERRORS_IGNORED.getW());
+        Assert.assertEquals(1, WriteConcern.JOURNALED.getW());
+        Assert.assertEquals(1, WriteConcern.FSYNCED.getW());
+        Assert.assertEquals(2, WriteConcern.REPLICA_ACKNOWLEDGED.getW());
+        Assert.assertEquals("majority", WriteConcern.MAJORITY.getWString());
+        Assert.assertEquals(2, WriteConcern.REPLICAS_SAFE.getW());
+        Assert.assertEquals("custom", new WriteConcern("custom").getWString());
+    }
+
     @Test
     public void testRaiseNetworkErrors() {
         Assert.assertFalse(WriteConcern.NONE.raiseNetworkErrors());
@@ -105,6 +127,10 @@ public void testRaiseNetworkErrors() {
         Assert.assertTrue(WriteConcern.ACKNOWLEDGED.raiseNetworkErrors());
         Assert.assertTrue(WriteConcern.FSYNC_SAFE.raiseNetworkErrors());
         Assert.assertTrue(WriteConcern.JOURNAL_SAFE.raiseNetworkErrors());
+        Assert.assertFalse(WriteConcern.ERRORS_IGNORED.raiseNetworkErrors());
+        Assert.assertTrue(WriteConcern.JOURNALED.raiseNetworkErrors());
+        Assert.assertTrue(WriteConcern.FSYNCED.raiseNetworkErrors());
+        Assert.assertTrue(WriteConcern.REPLICA_ACKNOWLEDGED.raiseNetworkErrors());
         Assert.assertTrue(WriteConcern.MAJORITY.raiseNetworkErrors());
         Assert.assertTrue(WriteConcern.REPLICAS_SAFE.raiseNetworkErrors());
         Assert.assertTrue(new WriteConcern("custom").raiseNetworkErrors());