void saImmOiFinalize_02(void)
{
safassert(saImmOiInitialize_2(&immOiHandle, &immOiCallbacks, &immVersion), SA_AIS_OK);
rc = saImmOiFinalize(-1);
test_validate(rc, SA_AIS_ERR_BAD_HANDLE);
safassert(saImmOiFinalize(immOiHandle), SA_AIS_OK);
}
void saImmOiClassImplementerSet_06(void)
{
const SaImmAdminOwnerNameT adminOwnerName = (SaImmAdminOwnerNameT) __FUNCTION__;
SaImmAdminOwnerHandleT ownerHandle;
SaImmCcbHandleT ccbHandle;
const SaNameT rdn = {strlen("Obj1"), "Obj1"};
const SaNameT* nameValues[] = {&rdn};
SaImmAttrValuesT_2 v2 = {"rdn", SA_IMM_ATTR_SANAMET, 1, (void**)nameValues};
SaUint32T int1Value1 = 7;
SaUint32T* int1Values[] = {&int1Value1};
SaImmAttrValuesT_2 v1 = {"attr1", SA_IMM_ATTR_SAUINT32T, 1, (void**)int1Values};
const SaImmAttrValuesT_2 * attrValues[] = {&v1, &v2, NULL};
/* Test interference between saImmOiObjectImplementerSet and saImmOiClassImplementerSet */
SaImmOiHandleT newhandle;
SaImmOiImplementerNameT implementerName = (SaImmOiImplementerNameT) __FUNCTION__;
SaImmOiImplementerNameT implementerName2 = (SaImmOiImplementerNameT) __FILE__;
safassert(saImmOmInitialize(&immOmHandle, NULL, &immVersion), SA_AIS_OK);
safassert(saImmOmAdminOwnerInitialize(immOmHandle, adminOwnerName, SA_TRUE, &ownerHandle), SA_AIS_OK);
safassert(saImmOmCcbInitialize(ownerHandle, 0, &ccbHandle), SA_AIS_OK);
safassert(config_class_create(immOmHandle), SA_AIS_OK);
/* Create test object under root */
safassert(saImmOmCcbObjectCreate_2(ccbHandle, "TestClassConfig", NULL, attrValues), SA_AIS_OK);
safassert(saImmOmCcbApply(ccbHandle), SA_AIS_OK);
safassert(saImmOiInitialize_2(&immOiHandle, &immOiCallbacks, &immVersion), SA_AIS_OK);
safassert(saImmOiImplementerSet(immOiHandle, implementerName), SA_AIS_OK);
safassert(saImmOiInitialize_2(&newhandle, &immOiCallbacks, &immVersion), SA_AIS_OK);
safassert(saImmOiImplementerSet(newhandle, implementerName2), SA_AIS_OK);
safassert(saImmOiObjectImplementerSet(newhandle, &rdn, SA_IMM_ONE), SA_AIS_OK);
rc = saImmOiClassImplementerSet(immOiHandle, configClassName);
/* Cleanup */
safassert(saImmOiObjectImplementerRelease(newhandle, &rdn, SA_IMM_ONE), SA_AIS_OK);
safassert(saImmOiImplementerClear(newhandle), SA_AIS_OK);
safassert(saImmOiImplementerClear(immOiHandle), SA_AIS_OK);
safassert(saImmOiFinalize(newhandle), SA_AIS_OK);
safassert(saImmOiFinalize(immOiHandle), SA_AIS_OK);
safassert(saImmOmCcbObjectDelete(ccbHandle, &rdn), SA_AIS_OK);
safassert(saImmOmCcbApply(ccbHandle), SA_AIS_OK);
safassert(saImmOmCcbFinalize(ccbHandle), SA_AIS_OK);
safassert(config_class_delete(immOmHandle), SA_AIS_OK);
safassert(saImmOmFinalize(immOmHandle), SA_AIS_OK);
test_validate(rc, SA_AIS_ERR_EXIST);
}
void saImmOiSelectionObjectGet_01(void)
{
safassert(saImmOiInitialize_2(&immOiHandle, &immOiCallbacks, &immVersion), SA_AIS_OK);
rc = saImmOiSelectionObjectGet(immOiHandle, &selectionObject);
test_validate(rc, SA_AIS_OK);
safassert(saImmOiFinalize(immOiHandle), SA_AIS_OK);
}
void saImmOiRtObjectCreate_2_04(void)
{
safassert(saImmOiInitialize_2(&immOiHandle, &immOiCallbacks, &immVersion), SA_AIS_OK);
rc = saImmOiRtObjectCreate_2(immOiHandle, className, &rootObj, attrValues);
test_validate(rc, SA_AIS_ERR_BAD_OPERATION);
safassert(saImmOiFinalize(immOiHandle), SA_AIS_OK);
}
void saImmOiClassImplementerSet_04(void)
{
SaImmOiImplementerNameT implementerName = (SaImmOiImplementerNameT) __FUNCTION__;
SaImmClassNameT nonExistingclassName = (SaImmClassNameT) "XXX";
safassert(saImmOiInitialize_2(&immOiHandle, &immOiCallbacks, &immVersion), SA_AIS_OK);
safassert(saImmOiImplementerSet(immOiHandle, implementerName), SA_AIS_OK);
test_validate(saImmOiClassImplementerSet(immOiHandle, nonExistingclassName), SA_AIS_ERR_NOT_EXIST);
safassert(saImmOiFinalize(immOiHandle), SA_AIS_OK);
}
void saImmOiRtObjectCreate_2_06(void)
{
SaImmOiHandleT newhandle;
const SaImmOiImplementerNameT implementerName = (SaImmOiImplementerNameT) __FUNCTION__;
const SaImmOiImplementerNameT implementerName2 = (SaImmOiImplementerNameT) "tet_imm_implementer2";
safassert(saImmOiInitialize_2(&immOiHandle, &immOiCallbacks, &immVersion), SA_AIS_OK);
safassert(saImmOiImplementerSet(immOiHandle, implementerName), SA_AIS_OK);
safassert(saImmOiRtObjectCreate_2(immOiHandle, "SaLogStream", &rootObj, attrValues), SA_AIS_OK);
/* try create the same object again using a new handle */
safassert(saImmOiInitialize_2(&newhandle, &immOiCallbacks, &immVersion), SA_AIS_OK);
safassert(saImmOiImplementerSet(newhandle, implementerName2), SA_AIS_OK);
rc = saImmOiRtObjectCreate_2(newhandle, "SaLogStream", &rootObj, attrValues);
test_validate(rc, SA_AIS_ERR_EXIST);
safassert(saImmOiRtObjectDelete(immOiHandle, &dnObj1), SA_AIS_OK);
safassert(saImmOiFinalize(immOiHandle), SA_AIS_OK);
safassert(saImmOiFinalize(newhandle), SA_AIS_OK);
}
void saImmOiRtObjectDelete_05(void)
{
const SaImmOiImplementerNameT implementerName = (SaImmOiImplementerNameT) __FUNCTION__;
safassert(saImmOiInitialize_2(&immOiHandle, &immOiCallbacks, &immVersion), SA_AIS_OK);
safassert(saImmOiImplementerSet(immOiHandle, implementerName), SA_AIS_OK);
rc = saImmOiRtObjectDelete(immOiHandle, &dn2);
test_validate(rc, SA_AIS_ERR_NOT_EXIST);
safassert(saImmOiFinalize(immOiHandle), SA_AIS_OK);
}
void saImmOiRtObjectDelete_06(void)
{
const SaImmOiImplementerNameT implementerName = (SaImmOiImplementerNameT) __FUNCTION__;
safassert(saImmOiInitialize_2(&immOiHandle, &immOiCallbacks, &immVersion), SA_AIS_OK);
safassert(saImmOiImplementerSet(immOiHandle, implementerName), SA_AIS_OK);
rc = saImmOiRtObjectDelete(immOiHandle, &config_obj_dn);
test_validate(rc, SA_AIS_ERR_BAD_OPERATION);
safassert(saImmOiFinalize(immOiHandle), SA_AIS_OK);
}
void saImmOiRtObjectCreate_2_03(void)
{
const SaImmOiImplementerNameT implementerName = (SaImmOiImplementerNameT) __FUNCTION__;
safassert(saImmOiInitialize_2(&immOiHandle, &immOiCallbacks, &immVersion), SA_AIS_OK);
safassert(saImmOiImplementerSet(immOiHandle, implementerName), SA_AIS_OK);
rc = saImmOiRtObjectCreate_2(-1, className, &rootObj, attrValues);
test_validate(rc, SA_AIS_ERR_BAD_HANDLE);
safassert(saImmOiFinalize(immOiHandle), SA_AIS_OK);
}
void saImmOiClassImplementerSet_03(void)
{
SaImmOiImplementerNameT implementerName = (SaImmOiImplementerNameT) __FUNCTION__;
safassert(saImmOiInitialize_2(&immOiHandle, &immOiCallbacks, &immVersion), SA_AIS_OK);
safassert(saImmOiImplementerSet(immOiHandle, implementerName), SA_AIS_OK);
safassert(saImmOmInitialize(&immOmHandle, NULL, &immVersion), SA_AIS_OK);
safassert(runtime_class_create(immOmHandle), SA_AIS_OK);
test_validate(saImmOiClassImplementerSet(immOiHandle, runtimeClassName), SA_AIS_ERR_BAD_OPERATION);
safassert(saImmOiFinalize(immOiHandle), SA_AIS_OK);
safassert(runtime_class_delete(immOmHandle), SA_AIS_OK);
safassert(saImmOmFinalize(immOmHandle), SA_AIS_OK);
}
void saImmOiRtObjectDelete_01(void)
{
const SaImmOiImplementerNameT implementerName = (SaImmOiImplementerNameT) __FUNCTION__;
safassert(saImmOiInitialize_2(&immOiHandle, &immOiCallbacks, &immVersion), SA_AIS_OK);
safassert(saImmOiImplementerSet(immOiHandle, implementerName), SA_AIS_OK);
safassert(saImmOiRtObjectCreate_2(immOiHandle, className, &config_obj_dn, attrValues), SA_AIS_OK);
rc = saImmOiRtObjectDelete(immOiHandle, &dn);
test_validate(rc, SA_AIS_OK);
safassert(saImmOiFinalize(immOiHandle), SA_AIS_OK);
}
void saImmOiClassImplementerSet_01(void)
{
SaImmOiImplementerNameT implementerName = (SaImmOiImplementerNameT) __FUNCTION__;
safassert(saImmOmInitialize(&immOmHandle, NULL, &immVersion), SA_AIS_OK);
safassert(config_class_create(immOmHandle), SA_AIS_OK);
safassert(saImmOiInitialize_2(&immOiHandle, &immOiCallbacks, &immVersion), SA_AIS_OK);
safassert(saImmOiImplementerSet(immOiHandle, implementerName), SA_AIS_OK);
test_validate(saImmOiClassImplementerSet(immOiHandle, configClassName), SA_AIS_OK);
safassert(saImmOiClassImplementerRelease(immOiHandle, configClassName), SA_AIS_OK);
safassert(saImmOiFinalize(immOiHandle), SA_AIS_OK);
safassert(config_class_delete(immOmHandle), SA_AIS_OK);
safassert(saImmOmFinalize(immOmHandle), SA_AIS_OK);
}
void immoi_finalize(SaImmHandleT immOiHandle){
int retry = 3;
SaAisErrorT rc;
if(immOiHandle) {
while(retry>0) {
rc = saImmOiFinalize(immOiHandle);
if (rc == SA_AIS_OK) {
break;
}
retry--;
usleep(300);
}
}
if(rc != SA_AIS_OK) {
syslog(LOG_ERR, "saImmOiFinalize() FAILED: %d", rc);
}
}
void saImmOiClassImplementerSet_02(void)
{
safassert(saImmOmInitialize(&immOmHandle, NULL, &immVersion), SA_AIS_OK);
safassert(config_class_create(immOmHandle), SA_AIS_OK);
safassert(saImmOiInitialize_2(&immOiHandle, &immOiCallbacks, &immVersion), SA_AIS_OK);
/* invalid */
if ((rc = saImmOiClassImplementerSet(-1, configClassName)) != SA_AIS_ERR_BAD_HANDLE)
goto done;
/* not associated with an implementer name.*/
rc = saImmOiClassImplementerSet(immOiHandle, configClassName);
done:
test_validate(rc, SA_AIS_ERR_BAD_HANDLE);
safassert(saImmOiFinalize(immOiHandle), SA_AIS_OK);
safassert(config_class_delete(immOmHandle), SA_AIS_OK);
safassert(saImmOmFinalize(immOmHandle), SA_AIS_OK);
}
void saImmOmCcbObjectModify_2_17(void)
{
const SaImmAdminOwnerNameT adminOwnerName = (SaImmAdminOwnerNameT) __FUNCTION__;
const SaImmOiImplementerNameT implementerName = (SaImmOiImplementerNameT) __FUNCTION__;
SaImmAdminOwnerHandleT ownerHandle;
SaImmCcbHandleT ccbHandle;
const SaNameT obj1 = { strlen("id=1"), "id=1" };
const SaNameT obj2 = { strlen("id=2"), "id=2" };
const SaNameT* attrValues[] = { &obj1 };
SaImmAttrValuesT_2 v1 = {"attr1", SA_IMM_ATTR_SANAMET, 1, (void**)attrValues};
SaImmAttrModificationT_2 attrMod = { SA_IMM_ATTR_VALUES_REPLACE, v1 };
const SaImmAttrModificationT_2 *attrMods[] = { &attrMod, NULL };
const SaNameT* rdnValues1[] = { &obj1 };
SaImmAttrValuesT_2 rdnAttr1 = { "rdn", SA_IMM_ATTR_SANAMET, 1, (void**)rdnValues1 };
const SaImmAttrValuesT_2 *attrValues1[] = { &rdnAttr1, NULL };
safassert(saImmOmInitialize(&immOmHandle, NULL, &immVersion), SA_AIS_OK);
safassert(saImmOmAdminOwnerInitialize(immOmHandle, adminOwnerName, SA_TRUE, &ownerHandle), SA_AIS_OK);
safassert(nodangling_class_create(immOmHandle), SA_AIS_OK);
safassert(runtime_class_create(immOmHandle), SA_AIS_OK);
safassert(object_create(immOmHandle, ownerHandle, nodanglingClassName, &obj2, NULL, NULL), SA_AIS_OK);
safassert(saImmOiInitialize_2(&immOiHandle, &immOiCallbacks, &immVersion), SA_AIS_OK);
safassert(saImmOiImplementerSet(immOiHandle, implementerName), SA_AIS_OK);
safassert(saImmOiRtObjectCreate_2(immOiHandle, runtimeClassName, NULL, attrValues1), SA_AIS_OK);
safassert(saImmOmCcbInitialize(ownerHandle, 0, &ccbHandle), SA_AIS_OK);
rc = saImmOmCcbObjectModify_2(ccbHandle, &obj2, attrMods);
safassert(saImmOmCcbFinalize(ccbHandle), SA_AIS_OK);
safassert(saImmOiRtObjectDelete(immOiHandle, &obj1), SA_AIS_OK);
safassert(saImmOiFinalize(immOiHandle), SA_AIS_OK);
safassert(object_delete(ownerHandle, &obj2, 1), SA_AIS_OK);
safassert(runtime_class_delete(immOmHandle), SA_AIS_OK);
safassert(nodangling_class_delete(immOmHandle), SA_AIS_OK);
safassert(saImmOmAdminOwnerFinalize(ownerHandle), SA_AIS_OK);
safassert(saImmOmFinalize(immOmHandle), SA_AIS_OK);
test_validate(rc, SA_AIS_ERR_INVALID_PARAM);
}
void saImmOiRtObjectCreate_2_01(void)
{
const SaImmOiImplementerNameT implementerName = (SaImmOiImplementerNameT) __FUNCTION__;
safassert(saImmOiInitialize_2(&immOiHandle, &immOiCallbacks, &immVersion), SA_AIS_OK);
safassert(saImmOiImplementerSet(immOiHandle, implementerName), SA_AIS_OK);
safassert(saImmOiRtObjectCreate_2(immOiHandle, className, NULL, NULL), SA_AIS_ERR_INVALID_PARAM);
/* Create under root */
if ((rc = saImmOiRtObjectCreate_2(immOiHandle, className, NULL, attrValues)) != SA_AIS_OK)
goto done;
safassert(saImmOiRtObjectDelete(immOiHandle, &rdnObj1), SA_AIS_OK);
/* Create under parent */
if ((rc = saImmOiRtObjectCreate_2(immOiHandle, className, &rootObj, attrValues)) != SA_AIS_OK)
goto done;
safassert(saImmOiRtObjectDelete(immOiHandle, &dnObj1), SA_AIS_OK);
done:
test_validate(rc, SA_AIS_OK);
safassert(saImmOiFinalize(immOiHandle), SA_AIS_OK);
}
void SaImmOiRtAttrUpdateCallbackT_01(void)
{
SaImmOiImplementerNameT implementerName = (SaImmOiImplementerNameT) __FUNCTION__;
SaImmAdminOwnerNameT admoName = (SaImmAdminOwnerNameT) implementerName;
struct pollfd fds[1];
int ret;
pthread_t thread;
TRACE_ENTER();
setup(admoName);
immOiCallbacks.saImmOiRtAttrUpdateCallback = saImmOiRtAttrUpdateCallback;
safassert(saImmOiInitialize_2(&immOiHandle, &immOiCallbacks, &immVersion), SA_AIS_OK);
safassert(saImmOiImplementerSet(immOiHandle, implementerName), SA_AIS_OK);
safassert(saImmOiClassImplementerSet(immOiHandle, className), SA_AIS_OK);
safassert(saImmOiSelectionObjectGet(immOiHandle, &selectionObject), SA_AIS_OK);
ret = pthread_create(&thread, NULL, test_saImmOmAccessorGet_2, &testObjectName);
assert(ret == 0);
fds[0].fd = (int) selectionObject;
fds[0].events = POLLIN;
ret = poll(fds, 1, 1000);
assert(ret == 1);
safassert(saImmOiDispatch(immOiHandle, SA_DISPATCH_ONE), SA_AIS_OK);
pthread_join(thread, NULL);
test_validate(SA_AIS_OK, SA_AIS_OK);
safassert(saImmOiClassImplementerRelease(immOiHandle, className), SA_AIS_OK);
safassert(saImmOiImplementerClear(immOiHandle), SA_AIS_OK);
safassert(saImmOiFinalize(immOiHandle), SA_AIS_OK);
immOiCallbacks.saImmOiRtAttrUpdateCallback = NULL;
tearDown();
TRACE_LEAVE();
}
void saImmOmThreadInterference_01(void) {
SaImmHandleT immHandle;
SaImmOiHandleT immOiHandle;
SaImmAdminOwnerHandleT ownerHandle;
SaImmSearchHandleT searchHandle;
SaImmCcbHandleT ccbHandle;
pthread_t threadid1, threadid2;
SaAisErrorT rc;
SaImmAttrDefinitionT_2 attrDef = { "rdn", SA_IMM_ATTR_SASTRINGT, SA_IMM_ATTR_RDN | SA_IMM_ATTR_CONFIG, NULL };
const SaImmAttrDefinitionT_2 *attrDefs[2] = { &attrDef, NULL };
SaImmClassCategoryT classCategory;
SaImmAttrDefinitionT_2 **attrDefinitions;
SaImmAccessorHandleT accessorHandle;
SaImmAttrNameT attributeNames[2] = { "SaImmAttrClassName", NULL};
SaImmAttrValuesT_2 **attributes;
SaImmAttrValueT objNames[2] = { &objectName, NULL };
SaImmAttrValuesT_2 attrValue = { (SaImmAttrNameT)"rdn", SA_IMM_ATTR_SANAMET, 1, (SaImmAttrValueT *)objNames };
const SaImmAttrValuesT_2 *attrValues[2] = { &attrValue, NULL };
SaImmAttrValueT modAttrValue[2] = { "Test", NULL };
const SaImmAttrModificationT_2 attrMod = { SA_IMM_ATTR_VALUES_REPLACE, { "attr4", SA_IMM_ATTR_SASTRINGT, 1, modAttrValue } };
const SaImmAttrModificationT_2 *attrMods[] = { &attrMod, NULL };
objectName.length = strlen("Obj1");
strcpy((char *)objectName.value, "Obj1");
/* management */
safassert(saImmOmInitialize(&immHandle, NULL, &immVersion), SA_AIS_OK);
safassert(saImmOmAdminOwnerInitialize(immHandle, adminOwnerName, SA_TRUE, &ownerHandle), SA_AIS_OK);
/* create test object */
safassert(saImmOmCcbInitialize(ownerHandle, 0, &ccbHandle), SA_AIS_OK);
safassert(saImmOmCcbObjectCreate_2(ccbHandle, configClassName, NULL, attrValues), SA_AIS_OK);
safassert(saImmOmCcbApply(ccbHandle), SA_AIS_OK);
safassert(saImmOmAdminOwnerSet(ownerHandle, objectNames, SA_IMM_ONE), SA_AIS_OK);
/* implementer */
isReady = 0;
isOiDone = 0;
safassert(saImmOiInitialize_2(&immOiHandle, &immOiCallbacks, &immVersion), SA_AIS_OK);
safassert(saImmOiImplementerSet(immOiHandle, implementerName), SA_AIS_OK);
safassert(saImmOiObjectImplementerSet(immOiHandle, &objectName, SA_IMM_ONE), SA_AIS_OK);
assert(!pthread_create(&threadid1, NULL, implementer_thread, &immOiHandle));
while(!isReady)
usleep(100);
/* "lock" IMM OM handle */
isReady = 0;
isOmDone = 0;
isAdminOperDone = 0;
assert(!pthread_create(&threadid2, NULL, lockomhandle_thread, &ownerHandle));
while(!isReady)
usleep(100);
/* OM function tests */
if((rc = saImmOmFinalize(immHandle)) != SA_AIS_ERR_LIBRARY) goto done;
if((rc = saImmOmClassCreate_2(immHandle, (const SaImmClassNameT)"TestClass", SA_IMM_CLASS_CONFIG, (const SaImmAttrDefinitionT_2 **)attrDefs)) != SA_AIS_ERR_LIBRARY) goto done;
if((rc = saImmOmClassDescriptionGet_2(immHandle, (const SaImmClassNameT)"TestClass", &classCategory, &attrDefinitions)) != SA_AIS_ERR_LIBRARY) goto done;
if((rc = saImmOmClassDelete(immHandle, (const SaImmClassNameT)"TestClass")) != SA_AIS_ERR_LIBRARY) goto done;
if((rc = saImmOmSearchInitialize_2(immHandle, NULL, SA_IMM_SUBTREE,
SA_IMM_SEARCH_ONE_ATTR | SA_IMM_SEARCH_GET_NO_ATTR, NULL, NULL, &searchHandle)) != SA_AIS_ERR_LIBRARY) goto done;
safassert(saImmOmAccessorInitialize(immHandle, &accessorHandle), SA_AIS_OK);
if((rc = saImmOmAccessorGet_2(accessorHandle, &objectName, attributeNames, &attributes)) != SA_AIS_ERR_LIBRARY) goto done;
safassert(saImmOmAccessorFinalize(accessorHandle), SA_AIS_OK);
if((rc = saImmOmCcbObjectModify_2(ccbHandle, &objectName, attrMods)) != SA_AIS_ERR_LIBRARY) goto done;
if((rc = saImmOmCcbObjectDelete(ccbHandle, &objectName)) != SA_AIS_ERR_LIBRARY) goto done;
done:
isAdminOperDone = 1;
while(!isOmDone)
usleep(200);
test_validate(rc, SA_AIS_ERR_LIBRARY);
/* Finalize OI handle */
safassert(saImmOiObjectImplementerRelease(immOiHandle, &objectName, SA_IMM_ONE), SA_AIS_OK);
safassert(saImmOiImplementerClear(immOiHandle), SA_AIS_OK);
safassert(saImmOiFinalize(immOiHandle), SA_AIS_OK);
/* Use pthread_detach() to remove pthread_create@@GLIBC leak from valgrind */
pthread_detach(threadid1);
pthread_detach(threadid2);
while(!isOiDone)
usleep(200);
/* Remove test object and test class */
safassert(saImmOmCcbObjectDelete(ccbHandle, &objectName), SA_AIS_OK);
safassert(saImmOmCcbApply(ccbHandle), SA_AIS_OK);
/* Finalize OM handles */
saImmOmCcbFinalize(ccbHandle);
saImmOmAdminOwnerRelease(ownerHandle, objectNames, SA_IMM_ONE);
saImmOmAdminOwnerFinalize(ownerHandle);
saImmOmFinalize(immHandle);
}
/****************************************************************************
* Name : eds_main_process
*
* Description : This is the function which is given as a input to the
* EDS task.
* This function will be select of both the FD's (AMF FD and
* Mail Box FD), depending on which FD has been selected, it
* will call the corresponding routines.
*
* Arguments : mbx - This is the mail box pointer on which EDS is
* going to block.
*
* Return Values : None.
*
* Notes : None.
*****************************************************************************/
void eds_main_process(SYSF_MBX *mbx)
{
NCS_SEL_OBJ mbx_fd;
SaAisErrorT error = SA_AIS_OK;
EDS_CB *eds_cb = NULL;
int term_fd;
TRACE_ENTER();
if (NULL == (eds_cb = (EDS_CB *)ncshm_take_hdl(NCS_SERVICE_ID_EDS, gl_eds_hdl))) {
LOG_ER("Global take handle failed");
return;
}
mbx_fd = m_NCS_IPC_GET_SEL_OBJ(&eds_cb->mbx);
/* Give back the handle */
ncshm_give_hdl(gl_eds_hdl);
/* Initialize with IMM */
if (eds_imm_init(eds_cb) != SA_AIS_OK) {
LOG_ER("Imm Init Failed. Exiting");
exit(EXIT_FAILURE);
}
daemon_sigterm_install(&term_fd);
/* Set up all file descriptors to listen to */
fds[FD_TERM].fd = term_fd;
fds[FD_TERM].events = POLLIN;
fds[FD_AMF].fd = eds_cb->amfSelectionObject;
fds[FD_AMF].events = POLLIN;
fds[FD_CLM].fd = eds_cb->clm_sel_obj;
fds[FD_CLM].events = POLLIN;
fds[FD_MBCSV].fd = eds_cb->mbcsv_sel_obj;
fds[FD_MBCSV].events = POLLIN;
fds[FD_MBX].fd = mbx_fd.rmv_obj;
fds[FD_MBX].events = POLLIN;
fds[FD_IMM].fd = eds_cb->imm_sel_obj;
fds[FD_IMM].events = POLLIN;
TRACE("Entering the forever loop");
while (1) {
if ((eds_cb->immOiHandle != 0) && (eds_cb->is_impl_set == true)){
fds[FD_IMM].fd = eds_cb->imm_sel_obj;
fds[FD_IMM].events = POLLIN;
nfds = NUM_FD;
} else {
nfds = NUM_FD - 1;
}
int ret = poll(fds, nfds, -1);
if (ret == -1) {
if (errno == EINTR)
continue;
TRACE("poll failed - %s", strerror(errno));
break;
}
/* process the sigterm */
if (fds[FD_TERM].revents & POLLIN) {
daemon_exit();
}
/* process all the AMF messages */
if (fds[FD_AMF].revents & POLLIN) {
/* dispatch all the AMF pending callbacks */
error = saAmfDispatch(eds_cb->amf_hdl, SA_DISPATCH_ALL);
if (error != SA_AIS_OK)
LOG_ER("AMF Dispatch failed with rc = %d",error);
}
/* process all mbcsv messages */
if (fds[FD_MBCSV].revents & POLLIN) {
error = eds_mbcsv_dispatch(eds_cb->mbcsv_hdl);
if (NCSCC_RC_SUCCESS != error)
LOG_ER("MBCSv Dispatch failed with rc = %d",error);
}
/* Process the EDS Mail box, if eds is ACTIVE. */
if (fds[FD_MBX].revents & POLLIN) {
/* now got the IPC mail box event */
eds_process_mbx(mbx);
}
/* process the CLM messages */
if (fds[FD_CLM].revents & POLLIN) {
/* dispatch all the AMF pending callbacks */
error = saClmDispatch(eds_cb->clm_hdl, SA_DISPATCH_ALL);
if (error != SA_AIS_OK)
LOG_ER("CLM Dispatch failed with rc = %d",error);
}
/* process the IMM messages */
if (eds_cb->immOiHandle && fds[FD_IMM].revents & POLLIN) {
/* dispatch the IMM event */
error = saImmOiDispatch(eds_cb->immOiHandle, SA_DISPATCH_ONE);
/*
** BAD_HANDLE is interpreted as an IMM service restart. Try
** reinitialize the IMM OI API in a background thread and let
** this thread do business as usual especially handling write
** requests.
**
** All other errors are treated as non-recoverable (fatal) and will
** cause an exit of the process.
*/
if (error == SA_AIS_ERR_BAD_HANDLE) {
TRACE("saImmOiDispatch returned BAD_HANDLE");
/* Invalidate the IMM OI handle. */
saImmOiFinalize(eds_cb->immOiHandle);
eds_cb->immOiHandle = 0;
eds_cb->is_impl_set = false;
eds_imm_reinit_bg(eds_cb);
} else if (error != SA_AIS_OK) {
LOG_ER("saImmOiDispatch FAILED with rc = %d", error);
break;
}
}
}
TRACE_LEAVE();
return;
} /* End eds_main_process() */
/**
* Forever wait on events and process them.
*/
static void main_process(void)
{
NCS_SEL_OBJ mbx_fd;
SaAisErrorT error = SA_AIS_OK;
TRACE_ENTER();
/*
The initialization of the IMM OM handle below is done to use a feature in the
IMM implementation. As long as one handle is initialized, IMM will not release the
MDS subscription just reused it for new handles.
When SMF uses SmfImmUtils new handles are created and released during the execution.
If the campaign is big the MDS system limit of max number of subscriptions may be exceeded
i.e. "ERR |MDTM: SYSTEM has crossed the max =500 subscriptions"
The code below will ensure there is always one IMM OM handle initialized.
*/
SaImmHandleT omHandle;
SaVersionT immVersion = { 'A', 2, 1 };
SaAisErrorT rc = immutil_saImmOmInitialize(&omHandle, NULL, &immVersion);
if (rc != SA_AIS_OK) {
LOG_ER("immutil_saImmOmInitialize faild, rc = %d", rc);
return;
}
/* end of IMM featue code */
mbx_fd = ncs_ipc_get_sel_obj(&smfd_cb->mbx);
/* Set up all file descriptors to listen to */
if (smfd_cb->nid_started)
fds[SMFD_AMF_FD].fd = smfd_cb->usr1_sel_obj.rmv_obj;
else
fds[SMFD_AMF_FD].fd = smfd_cb->amfSelectionObject;
fds[SMFD_AMF_FD].events = POLLIN;
fds[SMFD_MBX_FD].fd = mbx_fd.rmv_obj;
fds[SMFD_MBX_FD].events = POLLIN;
fds[SMFD_COI_FD].fd = smfd_cb->campaignSelectionObject;
fds[SMFD_COI_FD].events = POLLIN;
while (1) {
if (smfd_cb->campaignOiHandle != 0) {
fds[SMFD_COI_FD].fd = smfd_cb->campaignSelectionObject;
fds[SMFD_COI_FD].events = POLLIN;
nfds = SMFD_MAX_FD;
} else {
nfds = SMFD_MAX_FD -1 ;
}
int ret = poll(fds, nfds, -1);
if (ret == -1) {
if (errno == EINTR)
continue;
LOG_ER("poll failed - %s", strerror(errno));
break;
}
/* Process all the AMF messages */
if (fds[SMFD_AMF_FD].revents & POLLIN) {
if (smfd_cb->amf_hdl != 0) {
/* dispatch all the AMF pending function */
if ((error =
saAmfDispatch(smfd_cb->amf_hdl,
SA_DISPATCH_ALL)) !=
SA_AIS_OK) {
LOG_ER("saAmfDispatch failed: %u",
error);
break;
}
} else {
TRACE("SIGUSR1 event rec");
if (smfd_amf_init(smfd_cb) != NCSCC_RC_SUCCESS) {
LOG_ER("init amf failed");
break;
}
TRACE("AMF Initialization SUCCESS......");
fds[SMFD_AMF_FD].fd =
smfd_cb->amfSelectionObject;
}
}
/* Process all the Mail box events */
if (fds[SMFD_MBX_FD].revents & POLLIN) {
/* dispatch all the MBX events */
smfd_process_mbx(&smfd_cb->mbx);
}
/* Process all the Imm callback events */
if (fds[SMFD_COI_FD].revents & POLLIN) {
if ((error =
saImmOiDispatch(smfd_cb->campaignOiHandle,
SA_DISPATCH_ALL)) != SA_AIS_OK) {
/*
** BAD_HANDLE is interpreted as an IMM service restart. Try
** reinitialize the IMM OI API in a background thread and let
** this thread do business as usual especially handling write
** requests.
**
** All other errors are treated as non-recoverable (fatal) and will
** cause an exit of the process.
*/
if (error == SA_AIS_ERR_BAD_HANDLE) {
TRACE("main: saImmOiDispatch returned BAD_HANDLE");
/*
** Invalidate the IMM OI handle, this info is used in other
** locations. E.g. giving TRY_AGAIN responses to a create and
** close app stream requests. That is needed since the IMM OI
** is used in context of these functions.
*/
saImmOiFinalize(smfd_cb->campaignOiHandle );
smfd_cb->campaignOiHandle = 0;
/* Initiate IMM reinitializtion in the background */
smfd_coi_reinit_bg(smfd_cb);
} else if (error != SA_AIS_OK) {
LOG_ER("main: saImmOiDispatch FAILED %u", error);
break;
}
}
}
}
rc = immutil_saImmOmAdminOwnerFinalize(omHandle);
if (rc != SA_AIS_OK) {
LOG_ER("immutil_saImmOmAdminOwnerFinalize faild, rc = %d", rc);
}
}
/****************************************************************************
* Name : gld_se_lib_init
*
* Description : Invoked to Initialize the GLD
*
*
* Arguments :
* Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE..
*
* Notes : None.
*****************************************************************************/
uns32 gld_se_lib_init(NCS_LIB_REQ_INFO *req_info)
{
GLSV_GLD_CB *gld_cb;
SaAisErrorT amf_error;
uns32 res = NCSCC_RC_SUCCESS;
SaAmfHealthcheckKeyT Healthy;
int8 *health_key;
/* Register with Logging subsystem */
if (NCS_GLSV_LOG == 1)
gld_flx_log_reg();
/* Allocate and initialize the control block */
gld_cb = m_MMGR_ALLOC_GLSV_GLD_CB;
if (gld_cb == NULL) {
m_LOG_GLD_MEMFAIL(GLD_CB_ALLOC_FAILED, __FILE__, __LINE__);
return NCSCC_RC_FAILURE;
}
memset(gld_cb, 0, sizeof(GLSV_GLD_CB));
/* TBD- Pool id is to be set */
gl_gld_hdl = gld_cb->my_hdl = ncshm_create_hdl(gld_cb->hm_poolid, NCS_SERVICE_ID_GLD, (NCSCONTEXT)gld_cb);
if (0 == gld_cb->my_hdl) {
m_LOG_GLD_HEADLINE(GLD_CREATE_HANDLE_FAILED, NCSFL_SEV_ERROR, __FILE__, __LINE__, 0);
m_MMGR_FREE_GLSV_GLD_CB(gld_cb);
return NCSCC_RC_FAILURE;
}
/* Initialize the cb parameters */
if (gld_cb_init(gld_cb) != NCSCC_RC_SUCCESS) {
m_MMGR_FREE_GLSV_GLD_CB(gld_cb);
return NCSCC_RC_FAILURE;
}
/* Initialize amf framework */
if (gld_amf_init(gld_cb) != NCSCC_RC_SUCCESS) {
m_LOG_GLD_SVC_PRVDR(GLD_AMF_INIT_ERROR, NCSFL_SEV_ERROR, __FILE__, __LINE__);
m_MMGR_FREE_GLSV_GLD_CB(gld_cb);
return NCSCC_RC_FAILURE;
}
m_LOG_GLD_SVC_PRVDR(GLD_AMF_INIT_SUCCESS, NCSFL_SEV_INFO, __FILE__, __LINE__);
/* Bind to MDS */
if (gld_mds_init(gld_cb) != NCSCC_RC_SUCCESS) {
saAmfFinalize(gld_cb->amf_hdl);
m_MMGR_FREE_GLSV_GLD_CB(gld_cb);
m_LOG_GLD_SVC_PRVDR(GLD_MDS_INSTALL_FAIL, NCSFL_SEV_ERROR, __FILE__, __LINE__);
return NCSCC_RC_FAILURE;
} else
m_LOG_GLD_SVC_PRVDR(GLD_MDS_INSTALL_SUCCESS, NCSFL_SEV_INFO, __FILE__, __LINE__);
/* Initialise with the MBCSV service */
if (glsv_gld_mbcsv_register(gld_cb) != NCSCC_RC_SUCCESS) {
m_LOG_GLD_MBCSV(GLD_MBCSV_INIT_FAILED, NCSFL_SEV_ERROR, __FILE__, __LINE__);
gld_mds_shut(gld_cb);
saAmfFinalize(gld_cb->amf_hdl);
m_MMGR_FREE_GLSV_GLD_CB(gld_cb);
return NCSCC_RC_FAILURE;
} else {
m_LOG_GLD_MBCSV(GLD_MBCSV_INIT_SUCCESS, NCSFL_SEV_INFO, __FILE__, __LINE__);
}
/* register glsv with imm */
amf_error = gld_imm_init(gld_cb);
if (amf_error != SA_AIS_OK) {
glsv_gld_mbcsv_unregister(gld_cb);
gld_mds_shut(gld_cb);
saAmfFinalize(gld_cb->amf_hdl);
m_MMGR_FREE_GLSV_GLD_CB(gld_cb);
gld_log(NCSFL_SEV_ERROR, "Imm Init Failed %u\n", amf_error);
return NCSCC_RC_FAILURE;
}
/* TASK CREATION AND INITIALIZING THE MAILBOX */
if ((m_NCS_IPC_CREATE(&gld_cb->mbx) != NCSCC_RC_SUCCESS) ||
(m_NCS_IPC_ATTACH(&gld_cb->mbx) != NCSCC_RC_SUCCESS) ||
(m_NCS_TASK_CREATE((NCS_OS_CB)gld_main_process,
&gld_cb->mbx, "GLD", m_GLD_TASK_PRIORITY,
m_GLD_STACKSIZE,
&gld_cb->task_hdl) != NCSCC_RC_SUCCESS) ||
(m_NCS_TASK_START(gld_cb->task_hdl) != NCSCC_RC_SUCCESS)) {
m_LOG_GLD_HEADLINE(GLD_IPC_TASK_INIT, NCSFL_SEV_ERROR, __FILE__, __LINE__, 0);
saImmOiFinalize(gld_cb->immOiHandle);
glsv_gld_mbcsv_unregister(gld_cb);
gld_mds_shut(gld_cb);
saAmfFinalize(gld_cb->amf_hdl);
m_NCS_TASK_RELEASE(gld_cb->task_hdl);
m_NCS_IPC_RELEASE(&gld_cb->mbx, NULL);
m_MMGR_FREE_GLSV_GLD_CB(gld_cb);
return (NCSCC_RC_FAILURE);
}
m_NCS_EDU_HDL_INIT(&gld_cb->edu_hdl);
/* register GLD component with AvSv */
amf_error = saAmfComponentRegister(gld_cb->amf_hdl, &gld_cb->comp_name, (SaNameT *)NULL);
if (amf_error != SA_AIS_OK) {
m_LOG_GLD_SVC_PRVDR(GLD_AMF_REG_ERROR, NCSFL_SEV_ERROR, __FILE__, __LINE__);
m_NCS_EDU_HDL_FLUSH(&gld_cb->edu_hdl);
m_NCS_TASK_RELEASE(gld_cb->task_hdl);
m_NCS_IPC_RELEASE(&gld_cb->mbx, NULL);
saImmOiFinalize(gld_cb->immOiHandle);
glsv_gld_mbcsv_unregister(gld_cb);
gld_mds_shut(gld_cb);
saAmfFinalize(gld_cb->amf_hdl);
m_MMGR_FREE_GLSV_GLD_CB(gld_cb);
return NCSCC_RC_FAILURE;
} else
m_LOG_GLD_SVC_PRVDR(GLD_AMF_REG_SUCCESS, NCSFL_SEV_INFO, __FILE__, __LINE__);
/** start the AMF health check **/
memset(&Healthy, 0, sizeof(Healthy));
health_key = (int8 *)getenv("GLSV_ENV_HEALTHCHECK_KEY");
if (health_key == NULL) {
if (strlen("A1B2") < sizeof(Healthy.key))
strncpy((char *)Healthy.key, "A1B2", sizeof(Healthy.key));
m_LOG_GLD_HEADLINE(GLD_HEALTH_KEY_DEFAULT_SET, NCSFL_SEV_INFO, __FILE__, __LINE__, 0);
} else {
if (strlen((char *)health_key) < sizeof(Healthy.key))
strncpy((char *)Healthy.key, (char *)health_key, SA_AMF_HEALTHCHECK_KEY_MAX - 1);
}
Healthy.keyLen = strlen((char *)Healthy.key);
amf_error = saAmfHealthcheckStart(gld_cb->amf_hdl, &gld_cb->comp_name, &Healthy,
SA_AMF_HEALTHCHECK_AMF_INVOKED, SA_AMF_COMPONENT_FAILOVER);
if (amf_error != SA_AIS_OK) {
m_LOG_GLD_SVC_PRVDR(GLD_AMF_HLTH_CHK_START_FAIL, NCSFL_SEV_ERROR, __FILE__, __LINE__);
saAmfComponentUnregister(gld_cb->amf_hdl, &gld_cb->comp_name, (SaNameT *)NULL);
m_NCS_EDU_HDL_FLUSH(&gld_cb->edu_hdl);
m_NCS_TASK_RELEASE(gld_cb->task_hdl);
m_NCS_IPC_RELEASE(&gld_cb->mbx, NULL);
saImmOiFinalize(gld_cb->immOiHandle);
glsv_gld_mbcsv_unregister(gld_cb);
gld_mds_shut(gld_cb);
saAmfFinalize(gld_cb->amf_hdl);
m_MMGR_FREE_GLSV_GLD_CB(gld_cb);
} else
m_LOG_GLD_SVC_PRVDR(GLD_AMF_HLTH_CHK_START_DONE, NCSFL_SEV_INFO, __FILE__, __LINE__);
return (res);
}
void saImmOiFinalize_01(void)
{
safassert(saImmOiInitialize_2(&immOiHandle, &immOiCallbacks, &immVersion), SA_AIS_OK);
rc = saImmOiFinalize(immOiHandle);
test_validate(rc, SA_AIS_OK);
}
/**
* The main routine for the clms daemon.
* @param argc
* @param argv
*
* @return int
*/
int main(int argc, char *argv[])
{
NCS_SEL_OBJ mbx_fd;
SaAisErrorT error = SA_AIS_OK;
uint32_t rc;
osaf_cluster = NULL;
int term_fd;
int timeout = -1;
daemonize(argc, argv);
if (clms_init() != NCSCC_RC_SUCCESS) {
LOG_ER("clms_init failed");
goto done;
}
mbx_fd = ncs_ipc_get_sel_obj(&clms_cb->mbx);
daemon_sigterm_install(&term_fd);
/* Set up all file descriptors to listen to */
fds[FD_TERM].fd = term_fd;
fds[FD_TERM].events = POLLIN;
fds[FD_AMF].fd = clms_cb->nid_started ?
usr1_sel_obj.rmv_obj : clms_cb->amf_sel_obj;
fds[FD_AMF].events = POLLIN;
fds[FD_MBCSV].fd = clms_cb->mbcsv_sel_obj;
fds[FD_MBCSV].events = POLLIN;
fds[FD_MBX].fd = mbx_fd.rmv_obj;
fds[FD_MBX].events = POLLIN;
fds[FD_IMM].fd = clms_cb->imm_sel_obj;
fds[FD_IMM].events = POLLIN;
#ifdef ENABLE_AIS_PLM
fds[FD_PLM].fd = clms_cb->plm_sel_obj;
fds[FD_PLM].events = POLLIN;
#endif
while (1) {
if (clms_cb->rtu_pending == true) {
TRACE("There is an IMM task to be tried again. setting poll time out to 500");
timeout = 500;
} else {
timeout = -1;
}
if ((clms_cb->immOiHandle != 0) && (clms_cb->is_impl_set == true)) {
fds[FD_IMM].fd = clms_cb->imm_sel_obj;
fds[FD_IMM].events = POLLIN;
nfds = NUM_FD;
} else {
nfds = NUM_FD - 1;
}
int ret = poll(fds, nfds, timeout);
if (ret == -1) {
if (errno == EINTR)
continue;
LOG_ER("poll failed - %s", strerror(errno));
break;
}
if (ret == 0) {
/* Process any/all pending RTAttribute updates to IMM */
TRACE("poll time out processing pending updates");
clms_retry_pending_rtupdates();
continue;
}
if (fds[FD_TERM].revents & POLLIN) {
daemon_exit();
}
if (fds[FD_AMF].revents & POLLIN) {
if (clms_cb->amf_hdl != 0) {
if ((error = saAmfDispatch(clms_cb->amf_hdl, SA_DISPATCH_ALL)) != SA_AIS_OK) {
LOG_ER("saAmfDispatch failed: %u", error);
break;
}
} else {
TRACE("SIGUSR1 event rec");
ncs_sel_obj_rmv_ind(usr1_sel_obj, true, true);
ncs_sel_obj_destroy(usr1_sel_obj);
if (clms_amf_init(clms_cb) != NCSCC_RC_SUCCESS) {
LOG_ER("AMF Initialization failed");
break;
}
TRACE("AMF Initialization SUCCESS......");
fds[FD_AMF].fd = clms_cb->amf_sel_obj;
}
}
if (fds[FD_MBCSV].revents & POLLIN) {
if ((rc = clms_mbcsv_dispatch(clms_cb->mbcsv_hdl)) != NCSCC_RC_SUCCESS) {
LOG_ER("MBCSv Dispatch Failed");
break;
}
}
if (fds[FD_MBX].revents & POLLIN) {
clms_process_mbx(&clms_cb->mbx);
}
#ifdef ENABLE_AIS_PLM
/*Incase the Immnd restart is not supported fully,have to reint imm - TO Be Done */
if (clms_cb->reg_with_plm == SA_TRUE){
if (fds[FD_PLM].revents & POLLIN) {
if ((error = saPlmDispatch(clms_cb->plm_hdl, SA_DISPATCH_ALL)) != SA_AIS_OK) {
LOG_ER("saPlmDispatch FAILED: %u", error);
break;
}
}
}
#endif
if (clms_cb->immOiHandle && fds[FD_IMM].revents & POLLIN) {
if ((error = saImmOiDispatch(clms_cb->immOiHandle, SA_DISPATCH_ALL)) != SA_AIS_OK) {
if (error == SA_AIS_ERR_BAD_HANDLE) {
TRACE("main :saImmOiDispatch returned BAD_HANDLE");
/*
* Invalidate the IMM OI handle, this info is used in other
* locations. E.g. giving TRY_AGAIN responses to a create and
* close app stream requests. That is needed since the IMM OI
* is used in context of these functions.
*
* Also closing the handle. Finalize is ok with a bad handle
* that is bad because it is stale and this actually clears
* the handle from internal agent structures. In any case
* we ignore the return value from Finalize here.
*/
saImmOiFinalize(clms_cb->immOiHandle);
clms_cb->immOiHandle = 0;
clms_cb->is_impl_set = false;
/* Initiate IMM reinitializtion in the background */
clm_imm_reinit_bg(clms_cb);
} else if (error != SA_AIS_OK) {
LOG_ER("saImmOiDispatch FAILED: %u", error);
break;
}
}
}
/* Retry any pending updates */
if (clms_cb->rtu_pending == true)
clms_retry_pending_rtupdates();
} /* End while (1) */
done:
LOG_ER("Failed, exiting...");
TRACE_LEAVE();
exit(1);
}
void saImmOiDispatch_01(void)
{
safassert(saImmOiInitialize_2(&immOiHandle, &immOiCallbacks, &immVersion), SA_AIS_OK);
test_validate(saImmOiDispatch(immOiHandle, SA_DISPATCH_ALL), SA_AIS_OK);
safassert(saImmOiFinalize(immOiHandle), SA_AIS_OK);
}
void saImmOiDispatch_03(void)
{
safassert(saImmOiInitialize_2(&immOiHandle, &immOiCallbacks, &immVersion), SA_AIS_OK);
test_validate(saImmOiDispatch(-1, SA_DISPATCH_ONE), SA_AIS_ERR_BAD_HANDLE);
safassert(saImmOiFinalize(immOiHandle), SA_AIS_OK);
}
void saImmOiDispatch_04(void)
{
safassert(saImmOiInitialize_2(&immOiHandle, &immOiCallbacks, &immVersion), SA_AIS_OK);
test_validate(saImmOiDispatch(immOiHandle, -1), SA_AIS_ERR_INVALID_PARAM);
safassert(saImmOiFinalize(immOiHandle), SA_AIS_OK);
}
void saImmOiRtObjectCreate_2_07(void)
{
const SaImmOiImplementerNameT implementerName = (SaImmOiImplementerNameT) __FUNCTION__;
const char *long_name =
"123456789012345678901234567890123456789012345678901234567890123"; /* 63 chars long */
SaNameT rdnObj27;
rdnObj27.length = 64;
strncpy((char *) rdnObj27.value, long_name, 64);
SaImmAttrValueT nameValues27[] = {&long_name};
//const SaNameT *nameValues27[] = {&rdnObj27};
const SaImmAttrValuesT_2 v27 = { "safLgStr", SA_IMM_ATTR_SASTRINGT, 1, (void**)nameValues27 };
const SaImmAttrValuesT_2* attrValues27[] = {&v1, &v27, &v3, &v4, &v5, &v6, &v7, &v8, &v9, &v10, &v11, NULL};
SaNameT tmpName;
safassert(saImmOiInitialize_2(&immOiHandle, &immOiCallbacks, &immVersion), SA_AIS_OK);
safassert(saImmOiImplementerSet(immOiHandle, implementerName), SA_AIS_OK);
/*Create first rt object. */
safassert(saImmOiRtObjectCreate_2(immOiHandle, className, &rootObj, attrValues27), SA_AIS_OK);/*107 (63+44)*/
tmpName.length = 107;
strncpy((char *) tmpName.value,
"123456789012345678901234567890123456789012345678901234567890123,rdn=root", 107);
/*Create second rt object. */
safassert(saImmOiRtObjectCreate_2(immOiHandle, className, &tmpName, attrValues27), SA_AIS_OK);/* 171 (63 + 108)*/
tmpName.length = 171;
strncpy((char *) tmpName.value,
"123456789012345678901234567890123456789012345678901234567890123,"
"123456789012345678901234567890123456789012345678901234567890123,rdn=root", 171);
/*Create third rt object. */
safassert(saImmOiRtObjectCreate_2(immOiHandle, className, &tmpName, attrValues27), SA_AIS_OK);/* 235 (63 + 172) */
tmpName.length = 235;
strncpy((char *) tmpName.value,
"123456789012345678901234567890123456789012345678901234567890123,"
"123456789012345678901234567890123456789012345678901234567890123,"
"123456789012345678901234567890123456789012345678901234567890123,rdn=root", 235);
/*Create of fourth rt object should fail. */
rc = saImmOiRtObjectCreate_2(immOiHandle, className, &tmpName, attrValues27);/*299!! (63 + 236)*/
if(!osaf_is_extended_names_enabled()) {
test_validate(rc, SA_AIS_ERR_NAME_TOO_LONG);
} else {
test_validate(rc, SA_AIS_OK);
}
/*Tear down*/
tmpName.length = 107;
strncpy((char *) tmpName.value,
"123456789012345678901234567890123456789012345678901234567890123,rdn=root", 107);
/* Delete first rt object and all its subobjects! */
safassert(saImmOiRtObjectDelete(immOiHandle, &tmpName), SA_AIS_OK);
safassert(saImmOiFinalize(immOiHandle), SA_AIS_OK);
}
