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 saImmOiRtObjectDelete_04(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);
safassert(saImmOiImplementerClear(immOiHandle), SA_AIS_OK);
rc = saImmOiRtObjectDelete(immOiHandle, &dn);
test_validate(rc, SA_AIS_ERR_BAD_HANDLE);
safassert(saImmOiImplementerSet(immOiHandle, implementerName), SA_AIS_OK);
safassert(saImmOiRtObjectDelete(immOiHandle, &dn), SA_AIS_OK);
safassert(saImmOiFinalize(immOiHandle), SA_AIS_OK);
}
SaAisErrorT set_implementer(SaImmHandleT immOiHandle, const SaImmOiImplementerNameT implementerName,
const SaNameT *objectName, SaImmScopeT scope){
SaAisErrorT rc;
rc = saImmOiImplementerSet(immOiHandle, implementerName);
if (rc != SA_AIS_OK) {
if (rc==SA_AIS_ERR_EXIST)
syslog(LOG_INFO, "saImmOiImplementerSet() Implementer name already exist!");
else {
syslog(LOG_ERR, "saImmOiImplementerSet() failed, rc= %d", rc);
return rc;
}
}
rc = saImmOiObjectImplementerSet( immOiHandle, objectName, scope);
if (rc != SA_AIS_OK){
if (rc==SA_AIS_ERR_EXIST)
syslog(LOG_INFO, "saImmOiObjectImplementerSet() Object Implementer name already exist!");
else {
syslog(LOG_ERR, "saImmOiObjectImplementerSet() failed, rc= %d", rc);
return rc;
}
}
else {
syslog(LOG_ERR, "Object Implementer %s is set %s!",implementerName,(char*)objectName->value);
}
return rc;
}
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 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 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 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 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 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 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 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();
}
/**
* Initialize the OI interface, get a selection object and become applier
*
* @global_param max_waiting_time_ms: Wait max time for each operation.
* @global_param applier_name: The name of the "configuration change" applier
* @param *cb[out]
*
* @return (-1) if init fail
*/
int ntfimcn_imm_init(ntfimcn_cb_t *cb)
{
SaAisErrorT rc;
int internal_rc = 0;
int msecs_waited;
TRACE_ENTER();
/*
* Set IMM environment variable for synchronous timeout to 1 sec
*/
setenv("IMMA_SYNCR_TIMEOUT","100",1);
/*
* Initialize the IMM OI API
* -------------------------
*/
msecs_waited = 0;
rc = saImmOiInitialize_2(&cb->immOiHandle, &callbacks, &imm_version);
while ((rc == SA_AIS_ERR_TRY_AGAIN) && (msecs_waited < max_waiting_time_60s)) {
usleep(sleep_delay_ms * 1000);
msecs_waited += sleep_delay_ms;
rc = saImmOiInitialize_2(&cb->immOiHandle, &callbacks, &imm_version);
}
if (rc != SA_AIS_OK) {
LOG_ER("%s saImmOiInitialize_2 failed %s",__FUNCTION__,saf_error(rc));
internal_rc = NTFIMCN_INTERNAL_ERROR;
goto done;
}
/*
* Get a selection object for the IMM OI
* -------------------------------------
*/
msecs_waited = 0;
rc = saImmOiSelectionObjectGet(cb->immOiHandle, &cb->immSelectionObject);
while ((rc == SA_AIS_ERR_TRY_AGAIN) && (msecs_waited < max_waiting_time_60s)) {
usleep(sleep_delay_ms * 1000);
msecs_waited += sleep_delay_ms;
rc = saImmOiSelectionObjectGet(cb->immOiHandle, &cb->immSelectionObject);
}
if (rc != SA_AIS_OK) {
LOG_ER("%s saImmOiSelectionObjectGet failed %s",__FUNCTION__,saf_error(rc));
internal_rc = NTFIMCN_INTERNAL_ERROR;
goto done;
}
/*
* Become the "configuration change" applier
* -----------------------------------------
*/
SaImmOiImplementerNameT applier_name = applier_nameA;
msecs_waited = 0;
rc = saImmOiImplementerSet(cb->immOiHandle, applier_name);
while (((rc == SA_AIS_ERR_TRY_AGAIN) ||
(rc == SA_AIS_ERR_EXIST)) &&
(msecs_waited < max_waiting_time_60s)) {
usleep(sleep_delay_ms * 1000);
msecs_waited += sleep_delay_ms;
if (rc == SA_AIS_ERR_EXIST) {
if (strcmp( applier_name, applier_nameA) == 0) {
applier_name = applier_nameB;
} else {
applier_name = applier_nameA;
}
}
rc = saImmOiImplementerSet(cb->immOiHandle, applier_name);
}
if (rc != SA_AIS_OK) {
LOG_ER("%s Becoming an applier failed %s",__FUNCTION__,saf_error(rc));
internal_rc = NTFIMCN_INTERNAL_ERROR;
goto done;
}
/*
* Initialize the IMM OM API
* -------------------------
*/
msecs_waited = 0;
rc = saImmOmInitialize(&cb->immOmHandle, &omCallbacks, &imm_version);
while ((rc == SA_AIS_ERR_TRY_AGAIN) && (msecs_waited < max_waiting_time_60s)) {
usleep(sleep_delay_ms * 1000);
msecs_waited += sleep_delay_ms;
rc = saImmOmInitialize(&cb->immOmHandle, &omCallbacks, &imm_version);
}
if (rc != SA_AIS_OK) {
LOG_ER("%s saImmOmInitialize failed %s",__FUNCTION__,saf_error(rc));
internal_rc = NTFIMCN_INTERNAL_ERROR;
goto done;
}
done:
TRACE_LEAVE();
return internal_rc;
}
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);
}
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);
}
