Merge 7.3 -> 7.4

Author: Ole John Aske

storage/ndb/include/kernel/signaldata/SchemaTransImpl.hpp

@@ -1,4 +1,4 @@
-/* Copyright (c) 2007, 2013, Oracle and/or its affiliates. All rights reserved.
+/* Copyright (c) 2007, 2014, Oracle and/or its affiliates. All rights reserved.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -75,6 +75,7 @@ struct SchemaTransImplRef
   STATIC_CONST( GSN = GSN_SCHEMA_TRANS_IMPL_REF );
   enum ErrorCode {
     NoError = 0,
+    Busy = 701,
     NotMaster = 702,
     TooManySchemaTrans = 780,
     InvalidTransKey = 781,

storage/ndb/src/kernel/blocks/dbdict/Dbdict.cpp

@@ -27663,17 +27663,26 @@ Dbdict::execSCHEMA_TRANS_BEGIN_REQ(Signal* signal)
       break;
     }
 
-    if (c_takeOverInProgress)
+    if (!localTrans)
     {
-      /**
-       * There is a dict takeover in progress. There may thus another
-       * transaction that should be rolled backward or forward before we
-       * can allow another transaction to start.
-       */
-      jam();
-      setError(error, SchemaTransBeginRef::Busy, __LINE__);
-      break;
+      ndbassert(getOwnNodeId() == c_masterNodeId);
+      NodeRecordPtr masterNodePtr;
+      c_nodes.getPtr(masterNodePtr, c_masterNodeId);
+
+      if (masterNodePtr.p->nodeState == NodeRecord::NDB_MASTER_TAKEOVER)
+      {
+        jam();
+        /**
+         * There is a dict takeover in progress. There may thus be another
+         * transaction that should be rolled backward or forward before we
+         * can allow another transaction to start.
+         * (Multiple concurrent schema transactions are not supported)
+         */
+        setError(error, SchemaTransBeginRef::Busy, __LINE__);
+        break;
+      }
     }
+    ndbassert(!c_takeOverInProgress);
 
     if (!check_ndb_versions() && !localTrans)
     {
@@ -27853,8 +27862,7 @@ Dbdict::execSCHEMA_TRANS_END_REQ(Signal* signal)
   SchemaTransPtr trans_ptr;
   ErrorInfo error;
   do {
-    findSchemaTrans(trans_ptr, trans_key);
-    if (trans_ptr.isNull()) {
+    if (!findSchemaTrans(trans_ptr, trans_key)) {
       jam();
       setError(error, SchemaTransEndRef::InvalidTransKey, __LINE__);
       break;
@@ -27876,31 +27884,32 @@ Dbdict::execSCHEMA_TRANS_END_REQ(Signal* signal)
       break;
     }
 
-    if (c_takeOverInProgress)
+    if (!localTrans)
     {
-      /**
-       * There is a dict takeover in progress, and the transaction may thus
-       * be in an inconsistent state. Therefore we cannot process this request
-       * now.
-       */
-      jam();
-      setError(error, SchemaTransEndRef::Busy, __LINE__);
-      break;
+      ndbassert(getOwnNodeId() == c_masterNodeId);
+      NodeRecordPtr masterNodePtr;
+      c_nodes.getPtr(masterNodePtr, c_masterNodeId);
+
+      if (masterNodePtr.p->nodeState == NodeRecord::NDB_MASTER_TAKEOVER)
+      {
+        jam();
+        /**
+         * There is a dict takeover in progress.
+         * Transaction might be in an inconsistent state where its fate 
+         * has not been decided yet. When takeover eventually completes,
+         * it will ::sendTransClientReply() which will inform the client
+         * about the fate of the Txn in a TRANS_END_REP.
+         * For now we don't send any reply, and let the client wait for
+         * TRANS_END_REP.
+         */
+        return;
+      }
     }
+
 #ifdef MARTIN
     ndbout_c("Dbdict::execSCHEMA_TRANS_END_REQ: trans %u, state %u", trans_ptr.i, trans_ptr.p->m_state);
 #endif
 
-    //XXX Check state
-
-    if (hasError(trans_ptr.p->m_error))
-    {
-      jam();
-      ndbassert(false);
-      setError(error, SchemaTransEndRef::InvalidTransState, __LINE__);
-      break;
-    }
-
     bool localTrans2 = requestInfo & DictSignal::RF_LOCAL_TRANS;
     if (localTrans != localTrans2)
     {
@@ -27910,6 +27919,11 @@ Dbdict::execSCHEMA_TRANS_END_REQ(Signal* signal)
       break;
     }
 
+    // Assert that we are not in an inconsistent/incomplete state
+    ndbassert(!hasError(trans_ptr.p->m_error));
+    ndbassert(!c_takeOverInProgress);
+    ndbassert(trans_ptr.p->m_counter.done());
+
     trans_ptr.p->m_clientState = TransClient::EndReq;
 
     const bool doBackground = flags & SchemaTransEndReq::SchemaTransBackground;

storage/ndb/src/kernel/blocks/dbdict/Dbdict.hpp

@@ -2231,6 +2231,40 @@ class Dbdict: public SimulatedBlock {
       return;
     }
 
+    if (!localTrans)
+    {
+      ndbassert(getOwnNodeId() == c_masterNodeId);
+      NodeRecordPtr masterNodePtr;
+      c_nodes.getPtr(masterNodePtr, c_masterNodeId);
+
+      if (masterNodePtr.p->nodeState == NodeRecord::NDB_MASTER_TAKEOVER)
+      {
+        jam();
+        /**
+         * There is a dict takeover in progress, and the transaction may thus
+         * be in an inconsistent state where its fate has not been decided yet.
+         * If transaction is in error we return that error,
+         * else we return 'Busy' which will cause a later retry.
+         */
+        if (hasError(trans_ptr.p->m_error))
+        {
+          jam();
+          setError(error, trans_ptr.p->m_error);
+        }
+        else
+        {
+          jam();
+          setError(error, SchemaTransImplRef::Busy, __LINE__);
+        }
+        return;
+      }
+    }
+
+    // Assert that we are not in an inconsistent/incomplete state
+    ndbassert(!hasError(trans_ptr.p->m_error));
+    ndbassert(!c_takeOverInProgress);
+    ndbassert(trans_ptr.p->m_counter.done());   
+
     if (!seizeSchemaOp(trans_ptr, op_ptr, t_ptr)) {
       jam();
       setError(error, SchemaTransImplRef::TooManySchemaOps, __LINE__);

storage/ndb/src/ndbapi/NdbDictionaryImpl.cpp

@@ -9384,7 +9384,7 @@ NdbDictInterface::endSchemaTrans(Uint32 flags)
   req->flags = flags;
 
   int errCodes[] = {
-    SchemaTransBeginRef::NotMaster,
+    SchemaTransEndRef::NotMaster,
     0
   };
   int ret = dictSignal(