Fixing ReplicatedRepository so that transactions may be entered when the master

is unavailable as long as no changes are made to replicated storables.

3 files changed, 234 insertions, 78 deletions

diff --git a/src/main/java/com/amazon/carbonado/repo/replicated/ReadOnlyTransaction.java b/src/main/java/com/amazon/carbonado/repo/replicated/ReadOnlyTransaction.java
new file mode 100644
index 0000000..1666bf4
--- /dev/null
+++ b/src/main/java/com/amazon/carbonado/repo/replicated/ReadOnlyTransaction.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright 2006-2013 Amazon Technologies, Inc. or its affiliates.
+ * Amazon, Amazon.com and Carbonado are trademarks or registered trademarks
+ * of Amazon Technologies, Inc. or its affiliates.  All rights reserved.
+ *
+ * Licensed 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 com.amazon.carbonado.repo.replicated;
+
+import java.util.concurrent.TimeUnit;
+
+import com.amazon.carbonado.IsolationLevel;
+import com.amazon.carbonado.PersistException;
+import com.amazon.carbonado.Transaction;
+
+/**
+ * ReadOnlyTransaction wraps an another transaction. It's only function is to
+ * serve as a marker for the ReplicatedStorage triggers that no write
+ * operations are allowed.
+ *
+ * @author Jesse Morgan
+ */
+class ReadOnlyTransaction implements Transaction {
+    private final Transaction mTxn;
+
+    public ReadOnlyTransaction(Transaction txn) {
+        mTxn = txn;
+    }
+
+    @Override
+    public void commit() throws PersistException {
+        mTxn.commit();
+    }
+
+    @Override
+    public void exit() throws PersistException {
+        mTxn.exit();
+    }
+
+    @Override
+    public void setForUpdate(boolean forUpdate) {
+        mTxn.setForUpdate(forUpdate);
+    }
+
+    @Override
+    public boolean isForUpdate() {
+        return mTxn.isForUpdate();
+    }
+
+    @Override
+    public void setDesiredLockTimeout(int timeout, TimeUnit unit) {
+        mTxn.setDesiredLockTimeout(timeout, unit);
+    }
+
+    @Override
+    public IsolationLevel getIsolationLevel() {
+        return mTxn.getIsolationLevel();
+    }
+
+    @Override
+    public void detach() {
+        mTxn.detach();
+    }
+
+    @Override
+    public void attach() {
+        mTxn.attach();
+    }
+
+    @Override
+    public boolean preCommit() throws PersistException {
+        return mTxn.preCommit();
+    }
+
+    @Override
+    public String toString() {
+        return "ReadOnlyTransaction wrapping { " + mTxn.toString() + " }";
+    }
+}
+
diff --git a/src/main/java/com/amazon/carbonado/repo/replicated/ReplicatedRepository.java b/src/main/java/com/amazon/carbonado/repo/replicated/ReplicatedRepository.java
index 6cf0d6c..cfe021d 100644
--- a/src/main/java/com/amazon/carbonado/repo/replicated/ReplicatedRepository.java
+++ b/src/main/java/com/amazon/carbonado/repo/replicated/ReplicatedRepository.java
@@ -70,6 +70,7 @@ import com.amazon.carbonado.spi.StoragePool;
 

 import com.amazon.carbonado.txn.TransactionPair;

 

+import com.amazon.carbonado.util.BelatedCreationException;

 import com.amazon.carbonado.util.Throttle;

 

 /**

@@ -243,18 +244,36 @@ class ReplicatedRepository
     }

 

     public Transaction enterTransaction() {

-        return new TransactionPair(mMasterRepository.enterTransaction(),

-                                   mReplicaRepository.enterTransaction());

+        Transaction master;

+        try {

+            master = mMasterRepository.enterTransaction();

+        } catch (BelatedCreationException e) {

+            return new ReadOnlyTransaction(mReplicaRepository.enterTransaction());

+        }

+

+        return new TransactionPair(master, mReplicaRepository.enterTransaction());

     }

 

     public Transaction enterTransaction(IsolationLevel level) {

-        return new TransactionPair(mMasterRepository.enterTransaction(level),

-                                   mReplicaRepository.enterTransaction(level));

+        Transaction master;

+        try {

+            master = mMasterRepository.enterTransaction(level);

+        } catch (BelatedCreationException e) {

+            return new ReadOnlyTransaction(mReplicaRepository.enterTransaction(level));

+        }

+

+        return new TransactionPair(master, mReplicaRepository.enterTransaction(level));

     }

 

     public Transaction enterTopTransaction(IsolationLevel level) {

-        return new TransactionPair(mMasterRepository.enterTopTransaction(level),

-                                   mReplicaRepository.enterTopTransaction(level));

+        Transaction master;

+        try {

+            master = mMasterRepository.enterTopTransaction(level);

+        } catch (BelatedCreationException e) {

+            return new ReadOnlyTransaction(mReplicaRepository.enterTopTransaction(level));

+        }

+

+        return new TransactionPair(master, mReplicaRepository.enterTopTransaction(level));

     }

 

     public IsolationLevel getTransactionIsolationLevel() {

diff --git a/src/main/java/com/amazon/carbonado/repo/replicated/ReplicationTrigger.java b/src/main/java/com/amazon/carbonado/repo/replicated/ReplicationTrigger.java
index 4b01679..1b88e3e 100644
--- a/src/main/java/com/amazon/carbonado/repo/replicated/ReplicationTrigger.java
+++ b/src/main/java/com/amazon/carbonado/repo/replicated/ReplicationTrigger.java
@@ -83,99 +83,133 @@ class ReplicationTrigger<S extends Storable> extends Trigger<S> {
 

     @Override

     public Object beforeInsert(S replica) throws PersistException {

-        return beforeInsert(replica, false);

+        return beforeInsert(null, replica, false);

     }

 

     @Override

     public Object beforeTryInsert(S replica) throws PersistException {

-        return beforeInsert(replica, true);

+        return beforeInsert(null, replica, true);

     }

 

-    private Object beforeInsert(S replica, boolean forTry) throws PersistException {

-        final S master = mMasterStorage.prepare();

-        replica.copyAllProperties(master);

+    @Override

+    public Object beforeInsert(Transaction txn, S replica) throws PersistException {

+        return beforeInsert(txn, replica, false);

+    }

 

-        try {

-            if (forTry) {

-                if (!master.tryInsert()) {

-                    throw abortTry();

+    @Override

+    public Object beforeTryInsert(Transaction txn, S replica) throws PersistException {

+        return beforeInsert(txn, replica, true);

+    }

+

+    private Object beforeInsert(Transaction txn, S replica, boolean forTry) throws PersistException {

+        if (txn instanceof ReadOnlyTransaction) {

+            // This operation was intended to take place in a transaction, but

+            // the master repository was unavailable when the transaction was

+            // entered.

+                throw new PersistException("Current transaction is read-only.");

+            }

+

+            final S master = mMasterStorage.prepare();

+            replica.copyAllProperties(master);

+

+            try {

+                if (forTry) {

+                    if (!master.tryInsert()) {

+                        throw abortTry();

+                    }

+                } else {

+                    master.insert();

                 }

-            } else {

-                master.insert();

+            } catch (UniqueConstraintException e) {

+                // This may be caused by an inconsistency between replica and

+                // master. Here's one scenerio: user called tryLoad and saw the

+                // entry does not exist. So instead of calling update, he/she calls

+                // insert. If the master entry exists, then there is an

+                // inconsistency. The code below checks for this specific kind of

+                // error and repairs it by inserting a record in the replica.

+

+                // Here's another scenerio: Unique constraint was caused by an

+                // inconsistency with the values of the alternate keys. User

+                // expected alternate keys to have unique values, as indicated by

+                // replica.

+

+                repair(replica);

+

+                // Throw exception since we don't know what the user's intentions

+                // really are.

+                throw e;

             }

-        } catch (UniqueConstraintException e) {

-            // This may be caused by an inconsistency between replica and

-            // master. Here's one scenerio: user called tryLoad and saw the

-            // entry does not exist. So instead of calling update, he/she calls

-            // insert. If the master entry exists, then there is an

-            // inconsistency. The code below checks for this specific kind of

-            // error and repairs it by inserting a record in the replica.

 

-            // Here's another scenerio: Unique constraint was caused by an

-            // inconsistency with the values of the alternate keys. User

-            // expected alternate keys to have unique values, as indicated by

-            // replica.

+            // Master may have applied sequences to unitialized primary keys, so

+            // copy primary keys to replica. Mark properties as dirty to allow

+            // primary key to be changed.

+            replica.markPropertiesDirty();

 

-            repair(replica);

+            // Copy all properties in order to trigger constraints that

+            // master should have resolved.

+            master.copyAllProperties(replica);

 

-            // Throw exception since we don't know what the user's intentions

-            // really are.

-            throw e;

+            return null;

         }

 

-        // Master may have applied sequences to unitialized primary keys, so

-        // copy primary keys to replica. Mark properties as dirty to allow

-        // primary key to be changed.

-        replica.markPropertiesDirty();

+        @Override

+        public Object beforeUpdate(S replica) throws PersistException {

+            return beforeUpdate(null, replica, false);

+        }

 

-        // Copy all properties in order to trigger constraints that

-        // master should have resolved.

-        master.copyAllProperties(replica);

+        @Override

+        public Object beforeTryUpdate(S replica) throws PersistException {

+            return beforeUpdate(null, replica, true);

+        }

 

-        return null;

-    }

+        @Override

+        public Object beforeUpdate(Transaction txn, S replica) throws PersistException {

+            return beforeUpdate(txn, replica, false);

+        }

 

-    @Override

-    public Object beforeUpdate(S replica) throws PersistException {

-        return beforeUpdate(replica, false);

-    }

+        @Override

+        public Object beforeTryUpdate(Transaction txn, S replica) throws PersistException {

+            return beforeUpdate(txn, replica, true);

+        }

 

-    @Override

-    public Object beforeTryUpdate(S replica) throws PersistException {

-        return beforeUpdate(replica, true);

-    }

+        private Object beforeUpdate(Transaction txn, S replica, boolean forTry) throws PersistException {

+            if (txn instanceof ReadOnlyTransaction) {

+                // This operation was intended to take place in a transaction, but

+                // the master repository was unavailable when the transaction was

+                // entered.

+                throw new PersistException("Current transaction is read-only.");

+            }

 

-    private Object beforeUpdate(S replica, boolean forTry) throws PersistException {

-        final S master = mMasterStorage.prepare();

-        replica.copyPrimaryKeyProperties(master);

-        replica.copyVersionProperty(master);

-        replica.copyDirtyProperties(master);

+            final S master = mMasterStorage.prepare();

+            replica.copyPrimaryKeyProperties(master);

+            replica.copyVersionProperty(master);

+            replica.copyDirtyProperties(master);

 

-        try {

-            if (forTry) {

-                if (!master.tryUpdate()) {

-                    // Master record does not exist. To ensure consistency,

-                    // delete record from replica.

-                    if (tryDeleteReplica(replica)) {

-                        // Replica was inconsistent, but caller might be in a

-                        // transaction and rollback the repair. Run repair

-                        // again in separate thread to ensure it sticks.

-                        repair(replica);

-                    }

-                    throw abortTry();

-                }

-            } else {

-                try {

-                    master.update();

-                } catch (PersistNoneException e) {

-                    // Master record does not exist. To ensure consistency,

-                    // delete record from replica.

-                    if (tryDeleteReplica(replica)) {

-                        // Replica was inconsistent, but caller might be in a

-                        // transaction and rollback the repair. Run repair

-                        // again in separate thread to ensure it sticks.

-                        repair(replica);

+            try {

+                if (forTry) {

+                    if (!master.tryUpdate()) {

+                        // Master record does not exist. To ensure consistency,

+                        // delete record from replica.

+                        if (tryDeleteReplica(replica)) {

+                            // Replica was inconsistent, but caller might be in a

+                            // transaction and rollback the repair. Run repair

+                            // again in separate thread to ensure it sticks.

+                            repair(replica);

+                        }

+                        throw abortTry();

                     }

+                } else {

+                    try {

+                        master.update();

+                    } catch (PersistNoneException e) {

+                        // Master record does not exist. To ensure consistency,

+                        // delete record from replica.

+                        if (tryDeleteReplica(replica)) {

+                            // Replica was inconsistent, but caller might be in a

+                            // transaction and rollback the repair. Run repair

+                            // again in separate thread to ensure it sticks.

+                            repair(replica);

+                        }

                     throw e;

                 }

             }

@@ -199,6 +233,18 @@ class ReplicationTrigger<S extends Storable> extends Trigger<S> {
 

     @Override

     public Object beforeDelete(S replica) throws PersistException {

+        return beforeDelete(null, replica);

+    }

+

+    @Override

+    public Object beforeDelete(Transaction txn, S replica) throws PersistException {

+        if (txn instanceof ReadOnlyTransaction) {

+            // This operation was intended to take place in a transaction, but

+            // the master repository was unavailable when the transaction was

+            // entered.

+            throw new PersistException("Current transaction is read-only.");

+        }

+

         S master = mMasterStorage.prepare();

         replica.copyPrimaryKeyProperties(master);