APIs return SA_AIS_OK after the node leaves then rejoins cluster.
Section 3.2 of the MSG B.03.01 spec states that if a node leaves then
rejoins the cluster, APIs need to return ERR_UNAVAILABLE for handles that
were obtained before the node left the cluster.
APIs need to return ERR_UNAVAILABLE for handles that were obtained
before the node left the cluster.
---
src/msg/Makefile.am | 1 +
src/msg/agent/mqa_api.c | 97 +--
src/msg/agent/mqa_db.h | 1 +
src/msg/agent/mqa_def.h | 1 +
src/msg/agent/mqa_init.c | 26 +
src/msg/agent/mqa_mds.c | 14 +
src/msg/apitest/test_ErrUnavailable.cc | 1009 ++++++++++++++++++++++++++++++++
src/msg/msgnd/mqnd_evt.c | 42 +-
8 files changed, 1139 insertions(+), 52 deletions(-)
create mode 100644 src/msg/apitest/test_ErrUnavailable.cc
diff --git a/src/msg/Makefile.am b/src/msg/Makefile.am
index 9ec9e59..aeec6ca 100644
--- a/src/msg/Makefile.am
+++ b/src/msg/Makefile.am
@@ -205,6 +205,7 @@ noinst_HEADERS += \
bin_msgtest_SOURCES = \
src/msg/apitest/msgtest.c \
src/msg/apitest/test_saMsgVersionT.cc \
+ src/msg/apitest/test_ErrUnavailable.cc \
src/msg/apitest/tet_mqa_conf.c \
src/msg/apitest/tet_mqsv_util.c \
src/msg/apitest/tet_mqa.c
diff --git a/src/msg/agent/mqa_api.c b/src/msg/agent/mqa_api.c
index 5ef238a..eeec00e 100644
--- a/src/msg/agent/mqa_api.c
+++ b/src/msg/agent/mqa_api.c
@@ -256,6 +256,7 @@ SaAisErrorT saMsgInitialize(SaMsgHandleT *msgHandle,
}
if (rc == SA_AIS_OK) {
+ mqa_cb->clm_node_joined = true;
/* create the client node and populate it */
client_info = mqa_client_tree_find_and_add(mqa_cb, 0, true);
@@ -281,6 +282,8 @@ SaAisErrorT saMsgInitialize(SaMsgHandleT *msgHandle,
goto final3;
}
+ client_info->isStale = false;
+
if (msgCallbacks)
client_info->msgCallbacks = *msgCallbacks;
else
@@ -373,8 +376,8 @@ SaAisErrorT saMsgSelectionObjectGet(SaMsgHandleT msgHandle,
goto done;
}
if (client_info->version.majorVersion == MQA_MAJOR_VERSION) {
- if (!mqa_cb->clm_node_joined) {
- TRACE_2("ERR_UNAVAILABLE: MQD or MQND is down");
+ if (!mqa_cb->clm_node_joined || client_info->isStale) {
+ TRACE_2("ERR_UNAVAILABLE: node is not cluster member");
rc = SA_AIS_ERR_UNAVAILABLE;
goto done;
}
@@ -461,8 +464,8 @@ SaAisErrorT saMsgDispatch(SaMsgHandleT msgHandle,
}
if (client_info->version.majorVersion == MQA_MAJOR_VERSION) {
- if (!mqa_cb->clm_node_joined) {
- TRACE_2("ERR_UNAVAILABLE: MQD or MQND is down");
+ if (!mqa_cb->clm_node_joined || client_info->isStale) {
+ TRACE_2("ERR_UNAVAILABLE: node is not cluster member");
rc = SA_AIS_ERR_UNAVAILABLE;
m_NCS_UNLOCK(&mqa_cb->cb_lock, NCS_LOCK_WRITE);
goto done;
@@ -805,8 +808,8 @@ saMsgQueueOpen(SaMsgHandleT msgHandle, const SaNameT
*queueName,
}
if (client_info->version.majorVersion == MQA_MAJOR_VERSION) {
- if (!mqa_cb->clm_node_joined) {
- TRACE_2("ERR_UNAVAILABLE: MQD or MQND is down");
+ if (!mqa_cb->clm_node_joined || client_info->isStale) {
+ TRACE_2("ERR_UNAVAILABLE: node is not cluster member");
rc = SA_AIS_ERR_UNAVAILABLE;
goto done;
}
@@ -1086,8 +1089,8 @@ saMsgQueueOpenAsync(SaMsgHandleT msgHandle, SaInvocationT
invocation,
}
if (client_info->version.majorVersion == MQA_MAJOR_VERSION) {
- if (!mqa_cb->clm_node_joined) {
- TRACE_2("ERR_UNAVAILABLE: MQD or MQND is down");
+ if (!mqa_cb->clm_node_joined || client_info->isStale) {
+ TRACE_2("ERR_UNAVAILABLE: node is not cluster member");
rc = SA_AIS_ERR_UNAVAILABLE;
goto done;
}
@@ -1240,9 +1243,10 @@ SaAisErrorT saMsgQueueClose(SaMsgQueueHandleT
queueHandle)
if (queue_node->client_info->version.majorVersion ==
MQA_MAJOR_VERSION) {
- if ((!mqa_cb->clm_node_joined) &&
+ if ((!mqa_cb->clm_node_joined ||
+ queue_node->client_info->isStale) &&
(!queue_node->client_info->finalize)) {
- TRACE_2("ERR_UNAVAILABLE: MQD or MQND is down");
+ TRACE_2("ERR_UNAVAILABLE: node is not cluster member");
rc = SA_AIS_ERR_UNAVAILABLE;
m_NCS_UNLOCK(&mqa_cb->cb_lock, NCS_LOCK_WRITE);
m_MQSV_MQA_GIVEUP_MQA_CB;
@@ -1398,8 +1402,8 @@ SaAisErrorT saMsgQueueStatusGet(SaMsgHandleT msgHandle,
}
if (client_info->version.majorVersion == MQA_MAJOR_VERSION) {
- if (!mqa_cb->clm_node_joined) {
- TRACE_2("ERR_UNAVAILABLE: MQD or MQND is down");
+ if (!mqa_cb->clm_node_joined || client_info->isStale) {
+ TRACE_2("ERR_UNAVAILABLE: node is not cluster member");
rc = SA_AIS_ERR_UNAVAILABLE;
goto done;
}
@@ -1551,8 +1555,9 @@ SaAisErrorT saMsgQueueRetentionTimeSet(SaMsgQueueHandleT
queueHandle,
if (queue_node->client_info->version.majorVersion ==
MQA_MAJOR_VERSION) {
- if (!mqa_cb->clm_node_joined) {
- TRACE_2("ERR_UNAVAILABLE: MQD or MQND is down");
+ if (!mqa_cb->clm_node_joined ||
+ queue_node->client_info->isStale) {
+ TRACE_2("ERR_UNAVAILABLE: node is not cluster member");
rc = SA_AIS_ERR_UNAVAILABLE;
m_NCS_UNLOCK(&mqa_cb->cb_lock, NCS_LOCK_WRITE);
m_MQSV_MQA_GIVEUP_MQA_CB;
@@ -1697,8 +1702,8 @@ SaAisErrorT saMsgQueueUnlink(SaMsgHandleT msgHandle,
const SaNameT *queueName)
}
if (client_info->version.majorVersion == MQA_MAJOR_VERSION) {
- if (!mqa_cb->clm_node_joined) {
- TRACE_2("ERR_UNAVAILABLE: MQD or MQND is down");
+ if (!mqa_cb->clm_node_joined || client_info->isStale) {
+ TRACE_2("ERR_UNAVAILABLE: node is not cluster member");
rc = SA_AIS_ERR_UNAVAILABLE;
goto done;
}
@@ -2469,8 +2474,8 @@ SaAisErrorT saMsgMessageSend(SaMsgHandleT msgHandle,
const SaNameT *destination,
}
if (client_info->version.majorVersion == MQA_MAJOR_VERSION) {
- if (!mqa_cb->clm_node_joined) {
- TRACE_2("ERR_UNAVAILABLE: MQD or MQND is down");
+ if (!mqa_cb->clm_node_joined || client_info->isStale) {
+ TRACE_2("ERR_UNAVAILABLE: node is not cluster member");
rc = SA_AIS_ERR_UNAVAILABLE;
goto done;
}
@@ -2561,8 +2566,8 @@ SaAisErrorT saMsgMessageSendAsync(SaMsgHandleT msgHandle,
}
if (client_info->version.majorVersion == MQA_MAJOR_VERSION) {
- if (!mqa_cb->clm_node_joined) {
- TRACE_2("ERR_UNAVAILABLE: MQD or MQND is down");
+ if (!mqa_cb->clm_node_joined || client_info->isStale) {
+ TRACE_2("ERR_UNAVAILABLE: node is not cluster member");
rc = SA_AIS_ERR_UNAVAILABLE;
goto done;
}
@@ -2685,7 +2690,8 @@ SaAisErrorT mqa_receive_message(SaMsgQueueHandleT
queueHandle,
if (queue_node->client_info->version.majorVersion ==
MQA_MAJOR_VERSION) {
- if (!mqa_cb->clm_node_joined) {
+ if (!mqa_cb->clm_node_joined ||
+ queue_node->client_info->isStale) {
TRACE_2("ERR_UNAVAILABLE: MQD or MQND is down");
rc = SA_AIS_ERR_UNAVAILABLE;
goto done;
@@ -3335,8 +3341,9 @@ SaAisErrorT saMsgMessageCancel(SaMsgQueueHandleT
queueHandle)
}
if (queue_node->client_info->version.majorVersion ==
MQA_MAJOR_VERSION) {
- if (!mqa_cb->clm_node_joined) {
- TRACE_2("ERR_UNAVAILABLE: MQD or MQND is down");
+ if (!mqa_cb->clm_node_joined ||
+ queue_node->client_info->isStale) {
+ TRACE_2("ERR_UNAVAILABLE: node is not cluster member");
rc = SA_AIS_ERR_UNAVAILABLE;
m_NCS_UNLOCK(&mqa_cb->cb_lock, NCS_LOCK_WRITE);
m_MQSV_MQA_GIVEUP_MQA_CB;
@@ -3581,8 +3588,8 @@ SaAisErrorT saMsgMessageSendReceive(SaMsgHandleT
msgHandle,
}
if (client_info->version.majorVersion == MQA_MAJOR_VERSION) {
- if (!mqa_cb->clm_node_joined) {
- TRACE_2("ERR_UNAVAILABLE: MQD or MQND is down");
+ if (!mqa_cb->clm_node_joined || client_info->isStale) {
+ TRACE_2("ERR_UNAVAILABLE: node is not cluster member");
rc = SA_AIS_ERR_UNAVAILABLE;
m_NCS_UNLOCK(&mqa_cb->cb_lock, NCS_LOCK_WRITE);
m_MQSV_MQA_GIVEUP_MQA_CB;
@@ -4302,8 +4309,8 @@ SaAisErrorT saMsgMessageReply(SaMsgHandleT msgHandle,
return rc;
}
if (client_info->version.majorVersion == MQA_MAJOR_VERSION) {
- if (!mqa_cb->clm_node_joined) {
- TRACE_2("ERR_UNAVAILABLE: MQD or MQND is down");
+ if (!mqa_cb->clm_node_joined || client_info->isStale) {
+ TRACE_2("ERR_UNAVAILABLE: node is not cluster member");
rc = SA_AIS_ERR_UNAVAILABLE;
m_MQSV_MQA_GIVEUP_MQA_CB;
return rc;
@@ -4390,8 +4397,8 @@ SaAisErrorT saMsgMessageReplyAsync(SaMsgHandleT msgHandle,
return rc;
}
if (client_info->version.majorVersion == MQA_MAJOR_VERSION) {
- if (!mqa_cb->clm_node_joined) {
- TRACE_2("ERR_UNAVAILABLE: MQD or MQND is down");
+ if (!mqa_cb->clm_node_joined || client_info->isStale) {
+ TRACE_2("ERR_UNAVAILABLE: node is not cluster member");
rc = SA_AIS_ERR_UNAVAILABLE;
m_MQSV_MQA_GIVEUP_MQA_CB;
return rc;
@@ -4536,8 +4543,8 @@ SaAisErrorT saMsgQueueGroupCreate(SaMsgHandleT msgHandle,
}
if (client_info->version.majorVersion == MQA_MAJOR_VERSION) {
- if (!mqa_cb->clm_node_joined) {
- TRACE_2("ERR_UNAVAILABLE: MQD or MQND is down");
+ if (!mqa_cb->clm_node_joined || client_info->isStale) {
+ TRACE_2("ERR_UNAVAILABLE: node is not cluster member");
rc = SA_AIS_ERR_UNAVAILABLE;
m_NCS_UNLOCK(&mqa_cb->cb_lock, NCS_LOCK_WRITE);
goto done;
@@ -4658,8 +4665,8 @@ SaAisErrorT saMsgQueueGroupDelete(SaMsgHandleT msgHandle,
}
if (client_info->version.majorVersion == MQA_MAJOR_VERSION) {
- if (!mqa_cb->clm_node_joined) {
- TRACE_2("ERR_UNAVAILABLE: MQD or MQND is down");
+ if (!mqa_cb->clm_node_joined || client_info->isStale) {
+ TRACE_2("ERR_UNAVAILABLE: node is not cluster member");
rc = SA_AIS_ERR_UNAVAILABLE;
m_NCS_UNLOCK(&mqa_cb->cb_lock, NCS_LOCK_WRITE);
goto done;
@@ -4791,8 +4798,8 @@ SaAisErrorT saMsgQueueGroupInsert(SaMsgHandleT msgHandle,
}
if (client_info->version.majorVersion == MQA_MAJOR_VERSION) {
- if (!mqa_cb->clm_node_joined) {
- TRACE_2("ERR_UNAVAILABLE: MQD or MQND is down");
+ if (!mqa_cb->clm_node_joined || client_info->isStale) {
+ TRACE_2("ERR_UNAVAILABLE: node is not cluster member");
rc = SA_AIS_ERR_UNAVAILABLE;
m_NCS_UNLOCK(&mqa_cb->cb_lock, NCS_LOCK_WRITE);
goto done;
@@ -4922,8 +4929,8 @@ SaAisErrorT saMsgQueueGroupRemove(SaMsgHandleT msgHandle,
}
if (client_info->version.majorVersion == MQA_MAJOR_VERSION) {
- if (!mqa_cb->clm_node_joined) {
- TRACE_2("ERR_UNAVAILABLE: MQD or MQND is down");
+ if (!mqa_cb->clm_node_joined || client_info->isStale) {
+ TRACE_2("ERR_UNAVAILABLE: node is not cluster member");
rc = SA_AIS_ERR_UNAVAILABLE;
m_NCS_UNLOCK(&mqa_cb->cb_lock, NCS_LOCK_WRITE);
goto done;
@@ -5071,8 +5078,8 @@ saMsgQueueGroupTrack(SaMsgHandleT msgHandle, const
SaNameT *queueGroupName,
}
if (client_info->version.majorVersion == MQA_MAJOR_VERSION) {
- if (!mqa_cb->clm_node_joined) {
- TRACE_2("ERR_UNAVAILABLE: MQD or MQND is down");
+ if (!mqa_cb->clm_node_joined || client_info->isStale) {
+ TRACE_2("ERR_UNAVAILABLE: node is not cluster member");
rc = SA_AIS_ERR_UNAVAILABLE;
m_NCS_UNLOCK(&mqa_cb->cb_lock, NCS_LOCK_WRITE);
goto done;
@@ -5390,8 +5397,8 @@ SaAisErrorT saMsgQueueGroupTrackStop(SaMsgHandleT
msgHandle,
}
if (client_info->version.majorVersion == MQA_MAJOR_VERSION) {
- if (!mqa_cb->clm_node_joined) {
- TRACE_2("ERR_UNAVAILABLE: MQD or MQND is down");
+ if (!mqa_cb->clm_node_joined || client_info->isStale) {
+ TRACE_2("ERR_UNAVAILABLE: node is not cluster member");
rc = SA_AIS_ERR_UNAVAILABLE;
m_NCS_UNLOCK(&mqa_cb->cb_lock, NCS_LOCK_WRITE);
goto done1;
@@ -5503,8 +5510,8 @@ saMsgQueueGroupNotificationFree(SaMsgHandleT msgHandle,
}
if (client_info->version.majorVersion == MQA_MAJOR_VERSION) {
- if (!mqa_cb->clm_node_joined) {
- TRACE_2("ERR_UNAVAILABLE: MQD or MQND is down");
+ if (!mqa_cb->clm_node_joined || client_info->isStale) {
+ TRACE_2("ERR_UNAVAILABLE: node is not cluster member");
rc = SA_AIS_ERR_UNAVAILABLE;
goto done;
}
@@ -5569,8 +5576,8 @@ SaAisErrorT saMsgMessageDataFree(SaMsgHandleT msgHandle,
void *data)
}
if (client_info->version.majorVersion == MQA_MAJOR_VERSION) {
- if (!mqa_cb->clm_node_joined) {
- TRACE_2("ERR_UNAVAILABLE: MQD or MQND is down");
+ if (!mqa_cb->clm_node_joined || client_info->isStale) {
+ TRACE_2("ERR_UNAVAILABLE: node is not cluster member");
rc = SA_AIS_ERR_UNAVAILABLE;
goto done;
}
diff --git a/src/msg/agent/mqa_db.h b/src/msg/agent/mqa_db.h
index 6b3cb63..2883df2 100644
--- a/src/msg/agent/mqa_db.h
+++ b/src/msg/agent/mqa_db.h
@@ -94,6 +94,7 @@ typedef struct mqa_client_info {
SYSF_MBX callbk_mbx;
NCS_PATRICIA_TREE mqa_track_tree;
uint8_t finalize;
+ bool isStale;
SaVersionT version;
} MQA_CLIENT_INFO;
diff --git a/src/msg/agent/mqa_def.h b/src/msg/agent/mqa_def.h
index e2ea1c4..5472c3e 100644
--- a/src/msg/agent/mqa_def.h
+++ b/src/msg/agent/mqa_def.h
@@ -52,6 +52,7 @@
/* function prototypes for client handling*/
MQA_CLIENT_INFO *mqa_client_tree_find_and_add(MQA_CB *mqa_cb,
SaMsgHandleT hdl_id, bool flag);
+MQA_CLIENT_INFO *mqa_client_tree_find_next(MQA_CB *, SaMsgHandleT);
uint32_t mqa_client_tree_delete_node(MQA_CB *mqa_cb,
MQA_CLIENT_INFO *client_info);
void mqa_queue_reader(NCSCONTEXT context);
diff --git a/src/msg/agent/mqa_init.c b/src/msg/agent/mqa_init.c
index 164e562..d799e43 100644
--- a/src/msg/agent/mqa_init.c
+++ b/src/msg/agent/mqa_init.c
@@ -681,6 +681,32 @@ MQA_CLIENT_INFO *mqa_client_tree_find_and_add(MQA_CB
*mqa_cb,
}
/****************************************************************************
+ Name : mqa_client_tree_find_next
+
+ Description : This routine gets the next client from the tree
+
+ Arguments :
+ mqa_cb : pointer to the mqa control block.
+ hdl_id : the handle id.
+
+ Return Values : returns the MQA_CLIENT_INFO node.
+
+ Notes : The caller takes the cb lock before calling this function
+
+******************************************************************************/
+MQA_CLIENT_INFO *mqa_client_tree_find_next(MQA_CB *mqa_cb, SaMsgHandleT hdl_id)
+{
+ MQA_CLIENT_INFO *client_info = NULL;
+ TRACE_ENTER();
+
+ client_info = (MQA_CLIENT_INFO *)ncs_patricia_tree_getnext(
+ &mqa_cb->mqa_client_tree, (uint8_t *)&hdl_id);
+
+ TRACE_LEAVE();
+ return client_info;
+}
+
+/****************************************************************************
Name : mqa_track_tree_find_and_add
Description : This routine adds/searches the new group track element to the
diff --git a/src/msg/agent/mqa_mds.c b/src/msg/agent/mqa_mds.c
index 089f403..569d5e5 100644
--- a/src/msg/agent/mqa_mds.c
+++ b/src/msg/agent/mqa_mds.c
@@ -502,6 +502,20 @@ static uint32_t mqa_mds_rcv(MQA_CB *cb,
MDS_CALLBACK_RECEIVE_INFO *rcv_info)
} else if (evt->type == MQSV_EVT_MQP_REQ) {
cb->clm_node_joined =
evt->msg.mqp_req.info.clmNotify.node_joined;
+
+ if (!cb->clm_node_joined) {
+ /* tell all clients they are stale now */
+ MQA_CLIENT_INFO *client_info;
+ SaMsgHandleT msgHandle = 0;
+ for (client_info =
+ mqa_client_tree_find_next(cb, msgHandle);
+ client_info;
+ client_info = mqa_client_tree_find_next(
+ cb, client_info->msgHandle)) {
+ client_info->isStale = true;
+ }
+ }
+
return rc;
}
diff --git a/src/msg/apitest/test_ErrUnavailable.cc
b/src/msg/apitest/test_ErrUnavailable.cc
new file mode 100644
index 0000000..3f37f8d
--- /dev/null
+++ b/src/msg/apitest/test_ErrUnavailable.cc
@@ -0,0 +1,1009 @@
+#include <cassert>
+#include <cstdio>
+#include <cstring>
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <poll.h>
+#include <unistd.h>
+#include "msg/apitest/msgtest.h"
+#include "ais/include/saMsg.h"
+
+static SaVersionT msg3_1 = { 'B', 3, 0 };
+
+static const SaNameT queueName = {
+ sizeof("safMq=TestQueue") - 1,
+ "safMq=TestQueue"
+};
+
+static const SaNameT queueGroupName = {
+ sizeof("safMqg=TestQueueGroup") - 1,
+ "safMqg=TestQueueGroup"
+};
+
+static const SaMsgQueueCreationAttributesT creationAttributes = {
+ 0,
+ { 5, 5, 5, 5 },
+ SA_TIME_ONE_SECOND
+};
+
+static void queueOpenCallback(SaInvocationT invocation,
+ SaMsgQueueHandleT queueHandle,
+ SaAisErrorT error)
+{
+}
+
+static std::string getClmNodeName(void)
+{
+ std::ifstream ifs("/etc/opensaf/node_name");
+ std::string nodeName;
+
+ ifs >> nodeName;
+
+ return nodeName;
+}
+
+static void lockUnlockNode(bool lock)
+{
+ std::string command("immadm -o ");
+
+ if (lock)
+ command += '2';
+ else
+ command += '1';
+
+ command += " safNode=";
+
+ std::string nodeName(getClmNodeName());
+
+ command += nodeName;
+ command += ",safCluster=myClmCluster";
+
+ int rc(system(command.c_str()));
+
+ int status(WEXITSTATUS(rc));
+
+ if (status != 0) {
+ std::cerr << "unable to " << (lock ? "lock" : "unlock") << " local node"
+ << std::endl;
+ exit(EXIT_FAILURE);
+ }
+
+ sleep(1);
+}
+
+static void saErrUnavailable_01(void)
+{
+ lockUnlockNode(true);
+ SaMsgHandleT msgHandle;
+ SaAisErrorT rc = saMsgInitialize(&msgHandle, 0, &msg3_1);
+ test_validate(rc, SA_AIS_ERR_UNAVAILABLE);
+ lockUnlockNode(false);
+}
+
+static void saErrUnavailable_02(void)
+{
+ SaMsgHandleT msgHandle;
+ SaAisErrorT rc = saMsgInitialize(&msgHandle, 0, &msg3_1);
+ assert(rc == SA_AIS_OK);
+
+ lockUnlockNode(true);
+ SaSelectionObjectT selectionObject;
+ rc = saMsgSelectionObjectGet(msgHandle, &selectionObject);
+ test_validate(rc, SA_AIS_ERR_UNAVAILABLE);
+ lockUnlockNode(false);
+
+ rc = saMsgFinalize(msgHandle);
+ assert(rc == SA_AIS_OK);
+}
+
+static void saErrUnavailable_03(void)
+{
+ SaMsgHandleT msgHandle;
+ SaAisErrorT rc = saMsgInitialize(&msgHandle, 0, &msg3_1);
+ assert(rc == SA_AIS_OK);
+
+ lockUnlockNode(true);
+ rc = saMsgDispatch(msgHandle, SA_DISPATCH_ONE);
+ test_validate(rc, SA_AIS_ERR_UNAVAILABLE);
+ lockUnlockNode(false);
+
+ rc = saMsgFinalize(msgHandle);
+ assert(rc == SA_AIS_OK);
+}
+
+static void saErrUnavailable_04(void)
+{
+ SaMsgHandleT msgHandle;
+ SaAisErrorT rc = saMsgInitialize(&msgHandle, 0, &msg3_1);
+ assert(rc == SA_AIS_OK);
+
+ lockUnlockNode(true);
+ rc = saMsgFinalize(msgHandle);
+ test_validate(rc, SA_AIS_OK);
+ lockUnlockNode(false);
+}
+
+static void saErrUnavailable_05(void)
+{
+ SaMsgHandleT msgHandle;
+ SaAisErrorT rc = saMsgInitialize(&msgHandle, 0, &msg3_1);
+ assert(rc == SA_AIS_OK);
+
+ lockUnlockNode(true);
+ SaMsgQueueHandleT queueHandle;
+ rc = saMsgQueueOpen(msgHandle, &queueName, 0, 0, SA_TIME_END, &queueHandle);
+ test_validate(rc, SA_AIS_ERR_UNAVAILABLE);
+ lockUnlockNode(false);
+
+ rc = saMsgFinalize(msgHandle);
+ assert(rc == SA_AIS_OK);
+}
+
+static void saErrUnavailable_06(void)
+{
+ SaMsgHandleT msgHandle;
+ SaMsgCallbacksT callbacks = {
+ queueOpenCallback,
+ 0,
+ 0,
+ 0
+ };
+
+ SaAisErrorT rc = saMsgInitialize(&msgHandle, &callbacks, &msg3_1);
+ assert(rc == SA_AIS_OK);
+
+ lockUnlockNode(true);
+ rc = saMsgQueueOpenAsync(msgHandle, 1, &queueName, 0, 0);
+ test_validate(rc, SA_AIS_ERR_UNAVAILABLE);
+ lockUnlockNode(false);
+
+ rc = saMsgFinalize(msgHandle);
+ assert(rc == SA_AIS_OK);
+}
+
+static void saErrUnavailable_07(void)
+{
+ SaMsgHandleT msgHandle;
+ SaAisErrorT rc = saMsgInitialize(&msgHandle, 0, &msg3_1);
+ assert(rc == SA_AIS_OK);
+
+ SaMsgQueueHandleT queueHandle;
+ rc = saMsgQueueOpen(msgHandle,
+ &queueName,
+ &creationAttributes,
+ SA_MSG_QUEUE_CREATE,
+ SA_TIME_END,
+ &queueHandle);
+ assert(rc == SA_AIS_OK);
+
+ lockUnlockNode(true);
+ rc = saMsgQueueClose(queueHandle);
+ test_validate(rc, SA_AIS_ERR_UNAVAILABLE);
+ lockUnlockNode(false);
+
+ rc = saMsgFinalize(msgHandle);
+ assert(rc == SA_AIS_OK);
+}
+
+static void saErrUnavailable_08(void)
+{
+ SaMsgHandleT msgHandle;
+ SaAisErrorT rc = saMsgInitialize(&msgHandle, 0, &msg3_1);
+ assert(rc == SA_AIS_OK);
+
+ lockUnlockNode(true);
+ SaMsgQueueStatusT queueStatus;
+ rc = saMsgQueueStatusGet(msgHandle, &queueName, &queueStatus);
+ test_validate(rc, SA_AIS_ERR_UNAVAILABLE);
+ lockUnlockNode(false);
+
+ rc = saMsgFinalize(msgHandle);
+ assert(rc == SA_AIS_OK);
+}
+
+static void saErrUnavailable_09(void)
+{
+ SaMsgHandleT msgHandle;
+ SaAisErrorT rc = saMsgInitialize(&msgHandle, 0, &msg3_1);
+ assert(rc == SA_AIS_OK);
+
+ SaMsgQueueHandleT queueHandle;
+ rc = saMsgQueueOpen(msgHandle,
+ &queueName,
+ &creationAttributes,
+ SA_MSG_QUEUE_CREATE,
+ SA_TIME_END,
+ &queueHandle);
+ assert(rc == SA_AIS_OK);
+
+ lockUnlockNode(true);
+ SaTimeT rTime = SA_TIME_END;
+ rc = saMsgQueueRetentionTimeSet(queueHandle, &rTime);
+ test_validate(rc, SA_AIS_ERR_UNAVAILABLE);
+ lockUnlockNode(false);
+
+ rc = saMsgFinalize(msgHandle);
+ assert(rc == SA_AIS_OK);
+}
+
+static void saErrUnavailable_10(void)
+{
+ SaMsgHandleT msgHandle;
+ SaAisErrorT rc = saMsgInitialize(&msgHandle, 0, &msg3_1);
+ assert(rc == SA_AIS_OK);
+
+ SaMsgQueueHandleT queueHandle;
+ rc = saMsgQueueOpen(msgHandle,
+ &queueName,
+ &creationAttributes,
+ SA_MSG_QUEUE_CREATE,
+ SA_TIME_END,
+ &queueHandle);
+ assert(rc == SA_AIS_OK);
+
+ lockUnlockNode(true);
+ rc = saMsgQueueUnlink(msgHandle, &queueName);
+ test_validate(rc, SA_AIS_ERR_UNAVAILABLE);
+ lockUnlockNode(false);
+
+ rc = saMsgFinalize(msgHandle);
+ assert(rc == SA_AIS_OK);
+}
+
+static void saErrUnavailable_11(void)
+{
+ SaMsgHandleT msgHandle;
+ SaAisErrorT rc = saMsgInitialize(&msgHandle, 0, &msg3_1);
+ assert(rc == SA_AIS_OK);
+
+ lockUnlockNode(true);
+ rc = saMsgQueueGroupCreate(msgHandle, &queueGroupName,
SA_MSG_QUEUE_GROUP_ROUND_ROBIN);
+ test_validate(rc, SA_AIS_ERR_UNAVAILABLE);
+ lockUnlockNode(false);
+
+ rc = saMsgFinalize(msgHandle);
+ assert(rc == SA_AIS_OK);
+}
+
+static void saErrUnavailable_12(void)
+{
+ SaMsgHandleT msgHandle;
+ SaAisErrorT rc = saMsgInitialize(&msgHandle, 0, &msg3_1);
+ assert(rc == SA_AIS_OK);
+
+ lockUnlockNode(true);
+ rc = saMsgQueueGroupDelete(msgHandle, &queueGroupName);
+ test_validate(rc, SA_AIS_ERR_UNAVAILABLE);
+ lockUnlockNode(false);
+
+ rc = saMsgFinalize(msgHandle);
+ assert(rc == SA_AIS_OK);
+}
+
+static void saErrUnavailable_13(void)
+{
+ SaMsgHandleT msgHandle;
+ SaAisErrorT rc = saMsgInitialize(&msgHandle, 0, &msg3_1);
+ assert(rc == SA_AIS_OK);
+
+ lockUnlockNode(true);
+ rc = saMsgQueueGroupInsert(msgHandle, &queueGroupName, &queueName);
+ test_validate(rc, SA_AIS_ERR_UNAVAILABLE);
+ lockUnlockNode(false);
+
+ rc = saMsgFinalize(msgHandle);
+ assert(rc == SA_AIS_OK);
+}
+
+static void saErrUnavailable_14(void)
+{
+ SaMsgHandleT msgHandle;
+ SaAisErrorT rc = saMsgInitialize(&msgHandle, 0, &msg3_1);
+ assert(rc == SA_AIS_OK);
+
+ lockUnlockNode(true);
+ rc = saMsgQueueGroupRemove(msgHandle, &queueGroupName, &queueName);
+ test_validate(rc, SA_AIS_ERR_UNAVAILABLE);
+ lockUnlockNode(false);
+
+ rc = saMsgFinalize(msgHandle);
+ assert(rc == SA_AIS_OK);
+}
+
+static void saErrUnavailable_15(void)
+{
+ SaMsgHandleT msgHandle;
+ SaAisErrorT rc = saMsgInitialize(&msgHandle, 0, &msg3_1);
+ assert(rc == SA_AIS_OK);
+
+ lockUnlockNode(true);
+ rc = saMsgQueueGroupTrack(msgHandle, &queueGroupName, SA_TRACK_CHANGES, 0);
+ test_validate(rc, SA_AIS_ERR_UNAVAILABLE);
+ lockUnlockNode(false);
+
+ rc = saMsgFinalize(msgHandle);
+ assert(rc == SA_AIS_OK);
+}
+
+static void saErrUnavailable_16(void)
+{
+ SaMsgHandleT msgHandle;
+ SaAisErrorT rc = saMsgInitialize(&msgHandle, 0, &msg3_1);
+ assert(rc == SA_AIS_OK);
+
+ lockUnlockNode(true);
+ rc = saMsgQueueGroupTrackStop(msgHandle, &queueGroupName);
+ test_validate(rc, SA_AIS_ERR_UNAVAILABLE);
+ lockUnlockNode(false);
+
+ rc = saMsgFinalize(msgHandle);
+ assert(rc == SA_AIS_OK);
+}
+
+static void saErrUnavailable_17(void)
+{
+ SaMsgHandleT msgHandle;
+ SaAisErrorT rc = saMsgInitialize(&msgHandle, 0, &msg3_1);
+ assert(rc == SA_AIS_OK);
+
+ lockUnlockNode(true);
+ rc = saMsgQueueGroupNotificationFree(msgHandle, 0);
+ test_validate(rc, SA_AIS_ERR_UNAVAILABLE);
+ lockUnlockNode(false);
+
+ rc = saMsgFinalize(msgHandle);
+ assert(rc == SA_AIS_OK);
+}
+
+static void saErrUnavailable_18(void)
+{
+ SaMsgHandleT msgHandle;
+ SaAisErrorT rc = saMsgInitialize(&msgHandle, 0, &msg3_1);
+ assert(rc == SA_AIS_OK);
+
+ lockUnlockNode(true);
+ SaMsgMessageT message;
+ rc = saMsgMessageSend(msgHandle, &queueName, &message, SA_TIME_END);
+ test_validate(rc, SA_AIS_ERR_UNAVAILABLE);
+ lockUnlockNode(false);
+
+ rc = saMsgFinalize(msgHandle);
+ assert(rc == SA_AIS_OK);
+}
+
+static void saErrUnavailable_19(void)
+{
+ SaMsgHandleT msgHandle;
+ SaAisErrorT rc = saMsgInitialize(&msgHandle, 0, &msg3_1);
+ assert(rc == SA_AIS_OK);
+
+ lockUnlockNode(true);
+ SaMsgMessageT message;
+ rc = saMsgMessageSendAsync(msgHandle, 1, &queueName, &message, 0);
+ test_validate(rc, SA_AIS_ERR_UNAVAILABLE);
+ lockUnlockNode(false);
+
+ rc = saMsgFinalize(msgHandle);
+ assert(rc == SA_AIS_OK);
+}
+
+static void saErrUnavailable_20(void)
+{
+ SaMsgHandleT msgHandle;
+ SaAisErrorT rc = saMsgInitialize(&msgHandle, 0, &msg3_1);
+ assert(rc == SA_AIS_OK);
+
+ SaMsgQueueHandleT queueHandle;
+ rc = saMsgQueueOpen(msgHandle,
+ &queueName,
+ &creationAttributes,
+ SA_MSG_QUEUE_CREATE,
+ SA_TIME_END,
+ &queueHandle);
+ assert(rc == SA_AIS_OK);
+
+ lockUnlockNode(true);
+ SaMsgMessageT message;
+ SaMsgSenderIdT senderId;
+
+ rc = saMsgMessageGet(queueHandle, &message, 0, &senderId, 0);
+ test_validate(rc, SA_AIS_ERR_UNAVAILABLE);
+ lockUnlockNode(false);
+
+ rc = saMsgFinalize(msgHandle);
+ assert(rc == SA_AIS_OK);
+}
+
+static void saErrUnavailable_21(void)
+{
+ SaMsgHandleT msgHandle;
+ SaAisErrorT rc = saMsgInitialize(&msgHandle, 0, &msg3_1);
+ assert(rc == SA_AIS_OK);
+
+ lockUnlockNode(true);
+ rc = saMsgMessageDataFree(msgHandle, 0);
+ test_validate(rc, SA_AIS_ERR_UNAVAILABLE);
+ lockUnlockNode(false);
+
+ rc = saMsgFinalize(msgHandle);
+ assert(rc == SA_AIS_OK);
+}
+
+static void saErrUnavailable_22(void)
+{
+ SaMsgHandleT msgHandle;
+ SaAisErrorT rc = saMsgInitialize(&msgHandle, 0, &msg3_1);
+ assert(rc == SA_AIS_OK);
+
+ SaMsgQueueHandleT queueHandle;
+ rc = saMsgQueueOpen(msgHandle,
+ &queueName,
+ &creationAttributes,
+ SA_MSG_QUEUE_CREATE,
+ SA_TIME_END,
+ &queueHandle);
+ assert(rc == SA_AIS_OK);
+
+ lockUnlockNode(true);
+ rc = saMsgMessageCancel(queueHandle);
+ test_validate(rc, SA_AIS_ERR_UNAVAILABLE);
+ lockUnlockNode(false);
+
+ rc = saMsgFinalize(msgHandle);
+ assert(rc == SA_AIS_OK);
+}
+
+static void saErrUnavailable_23(void)
+{
+ SaMsgHandleT msgHandle;
+ SaAisErrorT rc = saMsgInitialize(&msgHandle, 0, &msg3_1);
+ assert(rc == SA_AIS_OK);
+
+ lockUnlockNode(true);
+ SaMsgMessageT message = { 0 }, receiveMessage;
+ rc = saMsgMessageSendReceive(msgHandle, &queueName, &message,
&receiveMessage, 0, SA_TIME_MAX);
+ test_validate(rc, SA_AIS_ERR_UNAVAILABLE);
+ lockUnlockNode(false);
+
+ rc = saMsgFinalize(msgHandle);
+ assert(rc == SA_AIS_OK);
+}
+
+static void saErrUnavailable_24(void)
+{
+ SaMsgHandleT msgHandle;
+ SaAisErrorT rc = saMsgInitialize(&msgHandle, 0, &msg3_1);
+ assert(rc == SA_AIS_OK);
+
+ lockUnlockNode(true);
+ SaMsgMessageT message;
+ SaMsgSenderIdT senderId;
+ rc = saMsgMessageReply(msgHandle, &message, &senderId, 0);
+ test_validate(rc, SA_AIS_ERR_UNAVAILABLE);
+ lockUnlockNode(false);
+
+ rc = saMsgFinalize(msgHandle);
+ assert(rc == SA_AIS_OK);
+}
+
+static void saErrUnavailable_25(void)
+{
+ SaMsgHandleT msgHandle;
+ SaAisErrorT rc = saMsgInitialize(&msgHandle, 0, &msg3_1);
+ assert(rc == SA_AIS_OK);
+
+ lockUnlockNode(true);
+ SaMsgMessageT message;
+ SaMsgSenderIdT senderId;
+ rc = saMsgMessageReplyAsync(msgHandle, 1, &message, &senderId, 0);
+ test_validate(rc, SA_AIS_ERR_UNAVAILABLE);
+ lockUnlockNode(false);
+
+ rc = saMsgFinalize(msgHandle);
+ assert(rc == SA_AIS_OK);
+}
+
+static void saErrUnavailable_30(void)
+{
+ lockUnlockNode(true);
+ SaMsgHandleT msgHandle;
+ SaAisErrorT rc = saMsgInitialize(&msgHandle, 0, &msg3_1);
+ assert(rc == SA_AIS_ERR_UNAVAILABLE);
+ lockUnlockNode(false);
+ rc = saMsgInitialize(&msgHandle, 0, &msg3_1);
+ test_validate(rc, SA_AIS_OK);
+ rc = saMsgFinalize(msgHandle);
+ assert(rc == SA_AIS_OK);
+}
+
+static void saErrUnavailable_31(void)
+{
+ SaMsgHandleT msgHandle;
+ SaAisErrorT rc = saMsgInitialize(&msgHandle, 0, &msg3_1);
+ assert(rc == SA_AIS_OK);
+
+ lockUnlockNode(true);
+ lockUnlockNode(false);
+ SaSelectionObjectT selectionObject;
+ rc = saMsgSelectionObjectGet(msgHandle, &selectionObject);
+ test_validate(rc, SA_AIS_ERR_UNAVAILABLE);
+
+ rc = saMsgFinalize(msgHandle);
+ assert(rc == SA_AIS_OK);
+}
+
+static void saErrUnavailable_32(void)
+{
+ SaMsgHandleT msgHandle;
+ SaAisErrorT rc = saMsgInitialize(&msgHandle, 0, &msg3_1);
+ assert(rc == SA_AIS_OK);
+
+ lockUnlockNode(true);
+ lockUnlockNode(false);
+ rc = saMsgDispatch(msgHandle, SA_DISPATCH_ONE);
+ test_validate(rc, SA_AIS_ERR_UNAVAILABLE);
+
+ rc = saMsgFinalize(msgHandle);
+ assert(rc == SA_AIS_OK);
+}
+
+static void saErrUnavailable_33(void)
+{
+ SaMsgHandleT msgHandle;
+ SaAisErrorT rc = saMsgInitialize(&msgHandle, 0, &msg3_1);
+ assert(rc == SA_AIS_OK);
+
+ lockUnlockNode(true);
+ lockUnlockNode(false);
+ rc = saMsgFinalize(msgHandle);
+ test_validate(rc, SA_AIS_OK);
+}
+
+static void saErrUnavailable_34(void)
+{
+ SaMsgHandleT msgHandle;
+ SaAisErrorT rc = saMsgInitialize(&msgHandle, 0, &msg3_1);
+ assert(rc == SA_AIS_OK);
+
+ lockUnlockNode(true);
+ lockUnlockNode(false);
+ SaMsgQueueHandleT queueHandle;
+ rc = saMsgQueueOpen(msgHandle, &queueName, 0, 0, SA_TIME_END, &queueHandle);
+ test_validate(rc, SA_AIS_ERR_UNAVAILABLE);
+
+ rc = saMsgFinalize(msgHandle);
+ assert(rc == SA_AIS_OK);
+}
+
+static void saErrUnavailable_35(void)
+{
+ SaMsgHandleT msgHandle;
+ SaMsgCallbacksT callbacks = {
+ queueOpenCallback,
+ 0,
+ 0,
+ 0
+ };
+
+ SaAisErrorT rc = saMsgInitialize(&msgHandle, &callbacks, &msg3_1);
+ assert(rc == SA_AIS_OK);
+
+ lockUnlockNode(true);
+ lockUnlockNode(false);
+ rc = saMsgQueueOpenAsync(msgHandle, 1, &queueName, 0, 0);
+ test_validate(rc, SA_AIS_ERR_UNAVAILABLE);
+
+ rc = saMsgFinalize(msgHandle);
+ assert(rc == SA_AIS_OK);
+}
+
+static void saErrUnavailable_36(void)
+{
+ SaMsgHandleT msgHandle;
+ SaAisErrorT rc = saMsgInitialize(&msgHandle, 0, &msg3_1);
+ assert(rc == SA_AIS_OK);
+
+ SaMsgQueueHandleT queueHandle;
+ rc = saMsgQueueOpen(msgHandle,
+ &queueName,
+ &creationAttributes,
+ SA_MSG_QUEUE_CREATE,
+ SA_TIME_END,
+ &queueHandle);
+ assert(rc == SA_AIS_OK);
+
+ lockUnlockNode(true);
+ lockUnlockNode(false);
+ rc = saMsgQueueClose(queueHandle);
+ test_validate(rc, SA_AIS_ERR_UNAVAILABLE);
+
+ rc = saMsgFinalize(msgHandle);
+ assert(rc == SA_AIS_OK);
+}
+
+static void saErrUnavailable_37(void)
+{
+ SaMsgHandleT msgHandle;
+ SaAisErrorT rc = saMsgInitialize(&msgHandle, 0, &msg3_1);
+ assert(rc == SA_AIS_OK);
+
+ lockUnlockNode(true);
+ lockUnlockNode(false);
+ SaMsgQueueStatusT queueStatus;
+ rc = saMsgQueueStatusGet(msgHandle, &queueName, &queueStatus);
+ test_validate(rc, SA_AIS_ERR_UNAVAILABLE);
+
+ rc = saMsgFinalize(msgHandle);
+ assert(rc == SA_AIS_OK);
+}
+
+static void saErrUnavailable_38(void)
+{
+ SaMsgHandleT msgHandle;
+ SaAisErrorT rc = saMsgInitialize(&msgHandle, 0, &msg3_1);
+ assert(rc == SA_AIS_OK);
+
+ SaMsgQueueHandleT queueHandle;
+ rc = saMsgQueueOpen(msgHandle,
+ &queueName,
+ &creationAttributes,
+ SA_MSG_QUEUE_CREATE,
+ SA_TIME_END,
+ &queueHandle);
+ assert(rc == SA_AIS_OK);
+
+ lockUnlockNode(true);
+ lockUnlockNode(false);
+ SaTimeT rTime = SA_TIME_END;
+ rc = saMsgQueueRetentionTimeSet(queueHandle, &rTime);
+ test_validate(rc, SA_AIS_ERR_UNAVAILABLE);
+
+ rc = saMsgFinalize(msgHandle);
+ assert(rc == SA_AIS_OK);
+}
+
+static void saErrUnavailable_39(void)
+{
+ SaMsgHandleT msgHandle;
+ SaAisErrorT rc = saMsgInitialize(&msgHandle, 0, &msg3_1);
+ assert(rc == SA_AIS_OK);
+
+ SaMsgQueueHandleT queueHandle;
+ rc = saMsgQueueOpen(msgHandle,
+ &queueName,
+ &creationAttributes,
+ SA_MSG_QUEUE_CREATE,
+ SA_TIME_END,
+ &queueHandle);
+ assert(rc == SA_AIS_OK);
+
+ lockUnlockNode(true);
+ lockUnlockNode(false);
+ rc = saMsgQueueUnlink(msgHandle, &queueName);
+ test_validate(rc, SA_AIS_ERR_UNAVAILABLE);
+
+ rc = saMsgFinalize(msgHandle);
+ assert(rc == SA_AIS_OK);
+}
+
+static void saErrUnavailable_40(void)
+{
+ SaMsgHandleT msgHandle;
+ SaAisErrorT rc = saMsgInitialize(&msgHandle, 0, &msg3_1);
+ assert(rc == SA_AIS_OK);
+
+ lockUnlockNode(true);
+ lockUnlockNode(false);
+ rc = saMsgQueueGroupCreate(msgHandle, &queueGroupName,
SA_MSG_QUEUE_GROUP_ROUND_ROBIN);
+ test_validate(rc, SA_AIS_ERR_UNAVAILABLE);
+
+ rc = saMsgFinalize(msgHandle);
+ assert(rc == SA_AIS_OK);
+}
+
+static void saErrUnavailable_41(void)
+{
+ SaMsgHandleT msgHandle;
+ SaAisErrorT rc = saMsgInitialize(&msgHandle, 0, &msg3_1);
+ assert(rc == SA_AIS_OK);
+
+ lockUnlockNode(true);
+ lockUnlockNode(false);
+ rc = saMsgQueueGroupDelete(msgHandle, &queueGroupName);
+ test_validate(rc, SA_AIS_ERR_UNAVAILABLE);
+
+ rc = saMsgFinalize(msgHandle);
+ assert(rc == SA_AIS_OK);
+}
+
+static void saErrUnavailable_42(void)
+{
+ SaMsgHandleT msgHandle;
+ SaAisErrorT rc = saMsgInitialize(&msgHandle, 0, &msg3_1);
+ assert(rc == SA_AIS_OK);
+
+ lockUnlockNode(true);
+ lockUnlockNode(false);
+ rc = saMsgQueueGroupInsert(msgHandle, &queueGroupName, &queueName);
+ test_validate(rc, SA_AIS_ERR_UNAVAILABLE);
+
+ rc = saMsgFinalize(msgHandle);
+ assert(rc == SA_AIS_OK);
+}
+
+static void saErrUnavailable_43(void)
+{
+ SaMsgHandleT msgHandle;
+ SaAisErrorT rc = saMsgInitialize(&msgHandle, 0, &msg3_1);
+ assert(rc == SA_AIS_OK);
+
+ lockUnlockNode(true);
+ lockUnlockNode(false);
+ rc = saMsgQueueGroupRemove(msgHandle, &queueGroupName, &queueName);
+ test_validate(rc, SA_AIS_ERR_UNAVAILABLE);
+
+ rc = saMsgFinalize(msgHandle);
+ assert(rc == SA_AIS_OK);
+}
+
+static void saErrUnavailable_44(void)
+{
+ SaMsgHandleT msgHandle;
+ SaAisErrorT rc = saMsgInitialize(&msgHandle, 0, &msg3_1);
+ assert(rc == SA_AIS_OK);
+
+ lockUnlockNode(true);
+ lockUnlockNode(false);
+ rc = saMsgQueueGroupTrack(msgHandle, &queueGroupName, SA_TRACK_CHANGES, 0);
+ test_validate(rc, SA_AIS_ERR_UNAVAILABLE);
+
+ rc = saMsgFinalize(msgHandle);
+ assert(rc == SA_AIS_OK);
+}
+
+static void saErrUnavailable_45(void)
+{
+ SaMsgHandleT msgHandle;
+ SaAisErrorT rc = saMsgInitialize(&msgHandle, 0, &msg3_1);
+ assert(rc == SA_AIS_OK);
+
+ lockUnlockNode(true);
+ lockUnlockNode(false);
+ rc = saMsgQueueGroupTrackStop(msgHandle, &queueGroupName);
+ test_validate(rc, SA_AIS_ERR_UNAVAILABLE);
+
+ rc = saMsgFinalize(msgHandle);
+ assert(rc == SA_AIS_OK);
+}
+
+static void saErrUnavailable_46(void)
+{
+ SaMsgHandleT msgHandle;
+ SaAisErrorT rc = saMsgInitialize(&msgHandle, 0, &msg3_1);
+ assert(rc == SA_AIS_OK);
+
+ lockUnlockNode(true);
+ lockUnlockNode(false);
+ rc = saMsgQueueGroupNotificationFree(msgHandle, 0);
+ test_validate(rc, SA_AIS_ERR_UNAVAILABLE);
+
+ rc = saMsgFinalize(msgHandle);
+ assert(rc == SA_AIS_OK);
+}
+
+static void saErrUnavailable_47(void)
+{
+ SaMsgHandleT msgHandle;
+ SaAisErrorT rc = saMsgInitialize(&msgHandle, 0, &msg3_1);
+ assert(rc == SA_AIS_OK);
+
+ lockUnlockNode(true);
+ lockUnlockNode(false);
+ SaMsgMessageT message;
+ rc = saMsgMessageSend(msgHandle, &queueName, &message, SA_TIME_END);
+ test_validate(rc, SA_AIS_ERR_UNAVAILABLE);
+
+ rc = saMsgFinalize(msgHandle);
+ assert(rc == SA_AIS_OK);
+}
+
+static void saErrUnavailable_48(void)
+{
+ SaMsgHandleT msgHandle;
+ SaAisErrorT rc = saMsgInitialize(&msgHandle, 0, &msg3_1);
+ assert(rc == SA_AIS_OK);
+
+ lockUnlockNode(true);
+ lockUnlockNode(false);
+ SaMsgMessageT message;
+ rc = saMsgMessageSendAsync(msgHandle, 1, &queueName, &message, 0);
+ test_validate(rc, SA_AIS_ERR_UNAVAILABLE);
+
+ rc = saMsgFinalize(msgHandle);
+ assert(rc == SA_AIS_OK);
+}
+
+static void saErrUnavailable_49(void)
+{
+ SaMsgHandleT msgHandle;
+ SaAisErrorT rc = saMsgInitialize(&msgHandle, 0, &msg3_1);
+ assert(rc == SA_AIS_OK);
+
+ SaMsgQueueHandleT queueHandle;
+ rc = saMsgQueueOpen(msgHandle,
+ &queueName,
+ &creationAttributes,
+ SA_MSG_QUEUE_CREATE,
+ SA_TIME_END,
+ &queueHandle);
+ assert(rc == SA_AIS_OK);
+
+ lockUnlockNode(true);
+ lockUnlockNode(false);
+ SaMsgMessageT message;
+ SaMsgSenderIdT senderId;
+
+ rc = saMsgMessageGet(queueHandle, &message, 0, &senderId, 0);
+ test_validate(rc, SA_AIS_ERR_UNAVAILABLE);
+
+ rc = saMsgFinalize(msgHandle);
+ assert(rc == SA_AIS_OK);
+}
+
+static void saErrUnavailable_50(void)
+{
+ SaMsgHandleT msgHandle;
+ SaAisErrorT rc = saMsgInitialize(&msgHandle, 0, &msg3_1);
+ assert(rc == SA_AIS_OK);
+
+ lockUnlockNode(true);
+ lockUnlockNode(false);
+ rc = saMsgMessageDataFree(msgHandle, 0);
+ test_validate(rc, SA_AIS_ERR_UNAVAILABLE);
+
+ rc = saMsgFinalize(msgHandle);
+ assert(rc == SA_AIS_OK);
+}
+
+static void saErrUnavailable_51(void)
+{
+ SaMsgHandleT msgHandle;
+ SaAisErrorT rc = saMsgInitialize(&msgHandle, 0, &msg3_1);
+ assert(rc == SA_AIS_OK);
+
+ SaMsgQueueHandleT queueHandle;
+ rc = saMsgQueueOpen(msgHandle,
+ &queueName,
+ &creationAttributes,
+ SA_MSG_QUEUE_CREATE,
+ SA_TIME_END,
+ &queueHandle);
+ assert(rc == SA_AIS_OK);
+
+ lockUnlockNode(true);
+ lockUnlockNode(false);
+ rc = saMsgMessageCancel(queueHandle);
+ test_validate(rc, SA_AIS_ERR_UNAVAILABLE);
+
+ rc = saMsgFinalize(msgHandle);
+ assert(rc == SA_AIS_OK);
+}
+
+static void saErrUnavailable_52(void)
+{
+ SaMsgHandleT msgHandle;
+ SaAisErrorT rc = saMsgInitialize(&msgHandle, 0, &msg3_1);
+ assert(rc == SA_AIS_OK);
+
+ lockUnlockNode(true);
+ lockUnlockNode(false);
+ SaMsgMessageT message = { 0 }, receiveMessage;
+ rc = saMsgMessageSendReceive(msgHandle, &queueName, &message,
&receiveMessage, 0, SA_TIME_MAX);
+ test_validate(rc, SA_AIS_ERR_UNAVAILABLE);
+
+ rc = saMsgFinalize(msgHandle);
+ assert(rc == SA_AIS_OK);
+}
+
+static void saErrUnavailable_53(void)
+{
+ SaMsgHandleT msgHandle;
+ SaAisErrorT rc = saMsgInitialize(&msgHandle, 0, &msg3_1);
+ assert(rc == SA_AIS_OK);
+
+ lockUnlockNode(true);
+ lockUnlockNode(false);
+ SaMsgMessageT message;
+ SaMsgSenderIdT senderId;
+ rc = saMsgMessageReply(msgHandle, &message, &senderId, 0);
+ test_validate(rc, SA_AIS_ERR_UNAVAILABLE);
+
+ rc = saMsgFinalize(msgHandle);
+ assert(rc == SA_AIS_OK);
+}
+
+static void saErrUnavailable_54(void)
+{
+ SaMsgHandleT msgHandle;
+ SaAisErrorT rc = saMsgInitialize(&msgHandle, 0, &msg3_1);
+ assert(rc == SA_AIS_OK);
+
+ lockUnlockNode(true);
+ lockUnlockNode(false);
+ SaMsgMessageT message;
+ SaMsgSenderIdT senderId;
+ rc = saMsgMessageReplyAsync(msgHandle, 1, &message, &senderId, 0);
+ test_validate(rc, SA_AIS_ERR_UNAVAILABLE);
+
+ rc = saMsgFinalize(msgHandle);
+ assert(rc == SA_AIS_OK);
+}
+
+
+__attribute__((constructor)) static void saErrUnavailable_constructor(void)
+{
+ test_suite_add(26, "SA_AIS_ERR_UNAVAILABLE Test Suite");
+ test_case_add(26, saErrUnavailable_01, "saMsgInitialize");
+ test_case_add(26, saErrUnavailable_02, "saMsgSelectionObjectGet");
+ test_case_add(26, saErrUnavailable_03, "saMsgDispatch");
+ test_case_add(26, saErrUnavailable_04, "saMsgFinalize");
+ test_case_add(26, saErrUnavailable_05, "saMsgQueueOpen");
+ test_case_add(26, saErrUnavailable_06, "saMsgQueueOpenAsync");
+ test_case_add(26, saErrUnavailable_07, "saMsgQueueClose");
+ test_case_add(26, saErrUnavailable_08, "saMsgQueueStatusGet");
+ test_case_add(26, saErrUnavailable_09, "saMsgQueueRetentionTimeSet");
+ test_case_add(26, saErrUnavailable_10, "saMsgQueueUnlink");
+ test_case_add(26, saErrUnavailable_11, "saMsgQueueGroupCreate");
+ test_case_add(26, saErrUnavailable_12, "saMsgQueueGroupDelete");
+ test_case_add(26, saErrUnavailable_13, "saMsgQueueGroupInsert");
+ test_case_add(26, saErrUnavailable_14, "saMsgQueueGroupRemove");
+ test_case_add(26, saErrUnavailable_15, "saMsgQueueGroupTrack");
+ test_case_add(26, saErrUnavailable_16, "saMsgQueueGroupTrackStop");
+ test_case_add(26, saErrUnavailable_17, "saMsgQueueGroupNotificationFree");
+ test_case_add(26, saErrUnavailable_18, "saMsgMessageSend");
+ test_case_add(26, saErrUnavailable_19, "saMsgMessageSendAsync");
+ test_case_add(26, saErrUnavailable_20, "saMsgMessageGet");
+ test_case_add(26, saErrUnavailable_21, "saMsgMessageDataFree");
+ test_case_add(26, saErrUnavailable_22, "saMsgMessageCancel");
+ test_case_add(26, saErrUnavailable_23, "saMsgMessageSendReceive");
+ test_case_add(26, saErrUnavailable_24, "saMsgMessageReply");
+ test_case_add(26, saErrUnavailable_25, "saMsgMessageReplyAsync");
+#if 0
+ test_case_add(26, saErrUnavailable_26, "saMsgQueueCapacityThresholdsSet");
+ test_case_add(26, saErrUnavailable_27, "saMsgQueueCapacityThresholdsGet");
+ test_case_add(26, saErrUnavailable_28, "saMsgMetadataSizeGet");
+ test_case_add(26, saErrUnavailable_29, "saMsgLimitGet");
+#endif
+ test_case_add(26, saErrUnavailable_30, "saMsgInitialize (stale)");
+ test_case_add(26, saErrUnavailable_31, "saMsgSelectionObjectGet (stale)");
+ test_case_add(26, saErrUnavailable_32, "saMsgDispatch (stale)");
+ test_case_add(26, saErrUnavailable_33, "saMsgFinalize (stale)");
+ test_case_add(26, saErrUnavailable_34, "saMsgQueueOpen (stale)");
+ test_case_add(26, saErrUnavailable_35, "saMsgQueueOpenAsync (stale)");
+ test_case_add(26, saErrUnavailable_36, "saMsgQueueClose (stale)");
+ test_case_add(26, saErrUnavailable_37, "saMsgQueueStatusGet (stale)");
+ test_case_add(26, saErrUnavailable_38, "saMsgQueueRetentionTimeSet (stale)");
+ test_case_add(26, saErrUnavailable_39, "saMsgQueueUnlink (stale)");
+ test_case_add(26, saErrUnavailable_40, "saMsgQueueGroupCreate (stale)");
+ test_case_add(26, saErrUnavailable_41, "saMsgQueueGroupDelete (stale)");
+ test_case_add(26, saErrUnavailable_42, "saMsgQueueGroupInsert (stale)");
+ test_case_add(26, saErrUnavailable_43, "saMsgQueueGroupRemove (stale)");
+ test_case_add(26, saErrUnavailable_44, "saMsgQueueGroupTrack (stale)");
+ test_case_add(26, saErrUnavailable_45, "saMsgQueueGroupTrackStop (stale)");
+ test_case_add(26, saErrUnavailable_46, "saMsgQueueGroupNotificationFree
(stale)");
+ test_case_add(26, saErrUnavailable_47, "saMsgMessageSend (stale)");
+ test_case_add(26, saErrUnavailable_48, "saMsgMessageSendAsync (stale)");
+ test_case_add(26, saErrUnavailable_49, "saMsgMessageGet (stale)");
+ test_case_add(26, saErrUnavailable_50, "saMsgMessageDataFree (stale)");
+ test_case_add(26, saErrUnavailable_51, "saMsgMessageCancel (stale)");
+ test_case_add(26, saErrUnavailable_52, "saMsgMessageSendReceive (stale)");
+ test_case_add(26, saErrUnavailable_53, "saMsgMessageReply (stale)");
+ test_case_add(26, saErrUnavailable_54, "saMsgMessageReplyAsync (stale)");
+#if 0
+ test_case_add(26, saErrUnavailable_55, "saMsgQueueCapacityThresholdsSet
(stale)");
+ test_case_add(26, saErrUnavailable_56, "saMsgQueueCapacityThresholdsGet
(stale)");
+ test_case_add(26, saErrUnavailable_57, "saMsgMetadataSizeGet (stale)");
+ test_case_add(26, saErrUnavailable_58, "saMsgLimitGet (stale)");
+#endif
+}
diff --git a/src/msg/msgnd/mqnd_evt.c b/src/msg/msgnd/mqnd_evt.c
index f1505f4..0c2a612 100644
--- a/src/msg/msgnd/mqnd_evt.c
+++ b/src/msg/msgnd/mqnd_evt.c
@@ -438,7 +438,11 @@ static uint32_t mqnd_evt_proc_mqp_qopen(MQND_CB *cb,
MQSV_EVT *evt)
ASAPi_OPR_INFO opr;
TRACE_ENTER();
- if (cb->is_restart_done)
+ if (!cb->clm_node_joined) {
+ TRACE("node is not cluster member");
+ err = SA_AIS_ERR_UNAVAILABLE;
+ goto error1;
+ } else if (cb->is_restart_done)
err = SA_AIS_OK;
else {
mqp_req = &evt->msg.mqp_req;
@@ -556,7 +560,11 @@ static uint32_t mqnd_evt_proc_mqp_qclose(MQND_CB *cb,
MQSV_EVT *evt)
goto send_rsp;
}
- if (cb->is_restart_done)
+ if (!cb->clm_node_joined) {
+ TRACE("node is not cluster member");
+ err = SA_AIS_ERR_UNAVAILABLE;
+ goto send_rsp;
+ } else if (cb->is_restart_done)
err = SA_AIS_OK;
else {
err = SA_AIS_ERR_TRY_AGAIN;
@@ -625,7 +633,11 @@ static uint32_t mqnd_evt_proc_unlink(MQND_CB *cb, MQSV_EVT
*evt)
ulink_req = &evt->msg.mqp_req.info.unlinkReq;
- if (cb->is_restart_done)
+ if (!cb->clm_node_joined) {
+ TRACE("node is not cluster member");
+ err = SA_AIS_ERR_UNAVAILABLE;
+ goto send_rsp;
+ } else if (cb->is_restart_done)
err = SA_AIS_OK;
else {
LOG_ER(
@@ -868,7 +880,11 @@ static uint32_t mqnd_evt_proc_status_req(MQND_CB *cb,
MQSV_EVT *evt)
sts_req = &evt->msg.mqp_req.info.statusReq;
- if (cb->is_restart_done)
+ if (!cb->clm_node_joined) {
+ TRACE("node is not cluster member");
+ err = SA_AIS_ERR_UNAVAILABLE;
+ goto send_rsp;
+ } else if (cb->is_restart_done)
err = SA_AIS_OK;
else {
err = SA_AIS_ERR_TRY_AGAIN;
@@ -1111,7 +1127,11 @@ static uint32_t mqnd_evt_proc_send_msg(MQND_CB *cb,
MQSV_DSEND_EVT *evt)
else
snd_msg = &evt->info.sndMsgAsync.SendMsg;
- if (!cb->is_restart_done) {
+ if (!cb->clm_node_joined) {
+ TRACE("node is not cluster member");
+ err = SA_AIS_ERR_UNAVAILABLE;
+ goto send_resp;
+ } else if (!cb->is_restart_done) {
LOG_ER(
"%s:%u: ERR_TRY_AGAIN: MQND is not completely Initialized",
__FILE__, __LINE__);
@@ -1583,7 +1603,11 @@ static uint32_t mqnd_evt_proc_qattr_get(MQND_CB *cb,
MQSV_EVT *evt)
qattr_req = &evt->msg.mqnd_ctrl.info.qattr_get;
- if (cb->is_restart_done)
+ if (!cb->clm_node_joined) {
+ TRACE("node is not cluster member");
+ err = SA_AIS_ERR_UNAVAILABLE;
+ goto send_rsp;
+ } else if (cb->is_restart_done)
err = SA_AIS_OK;
else {
LOG_ER(
@@ -1649,7 +1673,11 @@ static uint32_t mqnd_evt_proc_ret_time_set(MQND_CB *cb,
MQSV_EVT *evt)
MQSV_EVT rsp_evt;
TRACE_ENTER();
- if (cb->is_restart_done)
+ if (!cb->clm_node_joined) {
+ TRACE("node is not cluster member");
+ err = SA_AIS_ERR_UNAVAILABLE;
+ goto send_rsp;
+ } else if (cb->is_restart_done)
err = SA_AIS_OK;
else {
LOG_ER(
--
2.9.5
------------------------------------------------------------------------------
Check out the vibrant tech community on one of the world's most
engaging tech sites, Slashdot.org! http://sdm.link/slashdot
_______________________________________________
Opensaf-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/opensaf-devel
