SaAisErrorT immutil_saImmOmCcbObjectCreate_2(SaImmCcbHandleT immCcbHandle,
const SaImmClassNameT className,
const SaNameT *parent,
const SaImmAttrValuesT_2** attrValues)
{
SaAisErrorT rc = saImmOmCcbObjectCreate_2(immCcbHandle, className, parent, attrValues);
unsigned int nTries = 20;
while(rc == SA_AIS_ERR_TRY_AGAIN && nTries > 0){
usleep(300 * 1000);
rc = saImmOmCcbObjectCreate_2(immCcbHandle, className, parent, attrValues);
nTries--;
}
return rc;
}
static void saImmOmLongDn_03(void) {
SaImmHandleT immHandle;
SaImmAdminOwnerHandleT ownerHandle;
SaImmCcbHandleT ccbHandle;
SaAisErrorT rc;
SaNameT dn;
const SaImmAdminOwnerNameT ownerName = (const SaImmAdminOwnerNameT)__FUNCTION__;
SaImmAttrValueT rdnVal[1] = { (SaImmAttrValueT)&dn };
SaImmAttrValuesT_2 attrValue = { "rdn", SA_IMM_ATTR_SANAMET, 1, rdnVal };
const SaImmAttrValuesT_2 *attrValues[2] = { &attrValue, NULL };
safassert(saImmOmInitialize(&immHandle, NULL, &immVersion), SA_AIS_OK);
config_class_create(immHandle);
osaf_extended_name_lend(longDn, &dn);
safassert(saImmOmAdminOwnerInitialize(immHandle, ownerName, SA_TRUE, &ownerHandle), SA_AIS_OK);
safassert(saImmOmCcbInitialize(ownerHandle, 0, &ccbHandle), SA_AIS_OK);
rc = saImmOmCcbObjectCreate_2(ccbHandle, configClassName, NULL, attrValues);
saImmOmCcbApply(ccbHandle);
safassert(saImmOmCcbFinalize(ccbHandle), SA_AIS_OK);
safassert(object_delete(ownerHandle, &dn, 1), SA_AIS_OK);
config_class_delete(immHandle);
safassert(saImmOmAdminOwnerFinalize(ownerHandle), SA_AIS_OK);
safassert(saImmOmFinalize(immHandle), SA_AIS_OK);
test_validate(rc, SA_AIS_OK);
}
static PyObject*
immom_saImmOmCcbObjectCreate(PyObject *self, PyObject *args)
{
SaAisErrorT rc;
char* className;
char* parentStr;
PyObject* attrList;
SaNameT parentName;
unsigned int len, i;
SaImmAttrValuesT_2** attrValues;
if (!haveCcb)
return immom_aisException(SA_AIS_ERR_BAD_OPERATION);
if (!PyArg_ParseTuple(args, "ssO", &parentStr, &className, &attrList))
return NULL;
if (immom_saName(parentStr, &parentName) == NULL)
return NULL;
if (!PyList_Check(attrList))
return immom_aisException(SA_AIS_ERR_INVALID_PARAM);
len = PyList_Size(attrList);
attrValues = (SaImmAttrValuesT_2**)memget(
sizeof(SaImmAttrValuesT_2*) * (len+1));
attrValues[len] = NULL;
for (i = 0; i < len; i++) {
PyObject* item = PyList_GetItem(attrList, i);
char* attrName;
char* attrType;
PyObject* valueList;
SaImmAttrValuesT_2* av;
if (!PyTuple_Check(item))
return immom_aisException(SA_AIS_ERR_INVALID_PARAM);
if (!PyArg_ParseTuple(item, "ssO", &attrName, &attrType, &valueList))
return immom_return_null();
if (!PyList_Check(valueList))
return immom_aisException(SA_AIS_ERR_INVALID_PARAM);
av = (SaImmAttrValuesT_2*)memget(sizeof(SaImmAttrValuesT_2));
if (immom_parseAttrValue(av, attrName, attrType, valueList) == NULL)
return immom_return_null();
attrValues[i] = av;
}
rc = saImmOmCcbObjectCreate_2(
ccbHandle, className, &parentName,
(const SaImmAttrValuesT_2**)attrValues);
if (rc != SA_AIS_OK) return immom_aisException(rc);
return immom_return_None();
}
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);
}
static void setup(SaImmAdminOwnerNameT admoName)
{
SaAisErrorT err = SA_AIS_OK;
SaImmAttrDefinitionT_2 d1 =
{ "safComp", SA_IMM_ATTR_SANAMET,
SA_IMM_ATTR_CONFIG | SA_IMM_ATTR_RDN | SA_IMM_ATTR_INITIALIZED,
NULL };
SaImmAttrDefinitionT_2 d2 =
{ "saAmfCompRestartCount", SA_IMM_ATTR_SAINT32T,
SA_IMM_ATTR_RUNTIME, NULL };
/* Note class description not the complete standard class!
If the standard class exists we use it, if not we temporarily install
this dummy class.
*/
const SaImmAttrDefinitionT_2* attrDefs[4] = {&d1, &d2, 0};
SaImmAttrValuesT_2 v1=
{ "safComp", SA_IMM_ATTR_SANAMET, 1, (void**)nameValues };
const SaImmAttrValuesT_2* attrValues[2] = {&v1, 0};
safassert(saImmOmInitialize(&localImmHandle, NULL, &immVersion), SA_AIS_OK);
err = saImmOmClassCreate_2(localImmHandle, className, SA_IMM_CLASS_CONFIG, attrDefs);
if(err == SA_AIS_OK)
{
classCreated = SA_TRUE;
} else if(err == SA_AIS_ERR_EXIST)
{
err = SA_AIS_OK;
}
safassert(err, SA_AIS_OK);
/* Create the test object */
safassert(saImmOmAdminOwnerInitialize(localImmHandle, admoName, SA_TRUE, &localOwnerHandle), SA_AIS_OK);
safassert(saImmOmCcbInitialize(localOwnerHandle, 0LL, &localCcbHandle), SA_AIS_OK);
safassert(saImmOmCcbObjectCreate_2(localCcbHandle, className, NULL, attrValues), SA_AIS_OK);
safassert(saImmOmCcbApply(localCcbHandle), SA_AIS_OK);
sleep(1);
}
static SaAisErrorT config_object_create(SaImmHandleT immHandle,
SaImmAdminOwnerHandleT ownerHandle,
const SaNameT *parentName)
{
SaImmCcbHandleT ccbHandle;
const SaNameT* nameValues[] = {&rdnObj1, NULL};
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};
safassert(saImmOmCcbInitialize(ownerHandle, 0, &ccbHandle), SA_AIS_OK);
safassert(saImmOmCcbObjectCreate_2(ccbHandle, configClassName, parentName, attrValues), SA_AIS_OK);
safassert(saImmOmCcbApply(ccbHandle), SA_AIS_OK);
return saImmOmCcbFinalize(ccbHandle);
}
void saImmOmCcbApply_01(void)
{
const SaImmAdminOwnerNameT adminOwnerName =
(SaImmAdminOwnerNameT) __FUNCTION__;
SaImmAdminOwnerHandleT ownerHandle;
SaImmCcbHandleT ccbHandle;
SaNameT rdn = {strlen("Obj1"), "Obj1"};
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};
const SaNameT parentName = {strlen("opensafImm=opensafImm,safApp=safImmService"), "opensafImm=opensafImm,safApp=safImmService"};
const SaNameT *objectNames[] = {&parentName, NULL};
const SaNameT objectName =
{strlen("Obj1,opensafImm=opensafImm,safApp=safImmService"), "Obj1,opensafImm=opensafImm,safApp=safImmService"};
safassert(saImmOmInitialize(&immOmHandle, &immOmCallbacks, &immVersion),
SA_AIS_OK);
safassert(config_class_create(immOmHandle), SA_AIS_OK);
safassert(saImmOmAdminOwnerInitialize(immOmHandle, adminOwnerName,
/*SA_TRUE*/SA_FALSE, &ownerHandle), SA_AIS_OK);
safassert(saImmOmAdminOwnerSet(ownerHandle, objectNames, SA_IMM_ONE),
SA_AIS_OK);
safassert(saImmOmCcbInitialize(ownerHandle, 0, &ccbHandle), SA_AIS_OK);
safassert(saImmOmCcbObjectCreate_2(ccbHandle, configClassName,
&parentName, attrValues), SA_AIS_OK);
test_validate(saImmOmCcbApply(ccbHandle), SA_AIS_OK);
safassert(saImmOmCcbObjectDelete(ccbHandle, &objectName), SA_AIS_OK);
safassert(saImmOmCcbApply(ccbHandle), SA_AIS_OK);
safassert(saImmOmCcbFinalize(ccbHandle), SA_AIS_OK);
safassert(config_class_delete(immOmHandle), SA_AIS_OK);
safassert(saImmOmAdminOwnerRelease(ownerHandle, objectNames, SA_IMM_ONE),
SA_AIS_OK);
safassert(saImmOmAdminOwnerFinalize(ownerHandle), SA_AIS_OK);
safassert(saImmOmFinalize(immOmHandle), SA_AIS_OK);
}
void saImmOmCcbApply_02(void)
{
const SaImmAdminOwnerNameT adminOwnerName = (SaImmAdminOwnerNameT) __FUNCTION__;
SaImmAdminOwnerHandleT ownerHandle;
SaImmCcbHandleT ccbHandle;
SaNameT rdn = {strlen("Obj1"), "Obj1"};
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};
const SaNameT parentName = {strlen("opensafImm=opensafImm,safApp=safImmService"), "opensafImm=opensafImm,safApp=safImmService"};
const SaNameT *objectNames[] = {&parentName, NULL};
safassert(saImmOmInitialize(&immOmHandle, &immOmCallbacks, &immVersion), SA_AIS_OK);
safassert(config_class_create(immOmHandle), SA_AIS_OK);
safassert(saImmOmAdminOwnerInitialize(immOmHandle, adminOwnerName,
SA_TRUE, &ownerHandle), SA_AIS_OK);
safassert(saImmOmAdminOwnerSet(ownerHandle, objectNames, SA_IMM_ONE), SA_AIS_OK);
safassert(saImmOmCcbInitialize(ownerHandle, 0, &ccbHandle), SA_AIS_OK);
safassert(saImmOmCcbObjectCreate_2(ccbHandle, configClassName,
&parentName, attrValues), SA_AIS_OK);
/* ccbHandle is invalid */
if ((rc = saImmOmCcbApply(-1)) != SA_AIS_ERR_BAD_HANDLE)
goto done;
safassert(saImmOmCcbFinalize(ccbHandle), SA_AIS_OK);
/* ccbHandle has already been finalized. */
if ((rc = saImmOmCcbApply(ccbHandle)) != SA_AIS_ERR_BAD_HANDLE)
goto done;
done:
test_validate(rc, SA_AIS_ERR_BAD_HANDLE);
safassert(config_class_delete(immOmHandle), SA_AIS_OK);
safassert(saImmOmAdminOwnerFinalize(ownerHandle), SA_AIS_OK);
safassert(saImmOmFinalize(immOmHandle), SA_AIS_OK);
}
static SaAisErrorT config_object_create(SaImmHandleT immHandle,
SaImmAdminOwnerHandleT ownerHandle,
const SaNameT *parentName)
{
SaImmCcbHandleT ccbHandle;
const SaNameT* nameValues[] = {&rdnObj1, NULL};
SaImmAttrValuesT_2 v2 = {"rdn", SA_IMM_ATTR_SANAMET, 1, (void**)nameValues};
SaUint32T int1Value1 = __LINE__;
SaUint32T* int1Values[] = {&int1Value1};
SaStringT strValue1 = "String1-duplicate";
SaStringT strValue2 = "String2";
SaStringT* strValues[] = {&strValue2};
SaStringT* str2Values[] = {&strValue1, &strValue2, &strValue1};
SaImmAttrValuesT_2 v1 = {"attr1", SA_IMM_ATTR_SAUINT32T, 1, (void**)int1Values};
SaImmAttrValuesT_2 v3 = {"attr3", SA_IMM_ATTR_SASTRINGT, 3, (void**)str2Values};
SaImmAttrValuesT_2 v4 = {"attr4", SA_IMM_ATTR_SASTRINGT, 1, (void**)strValues};
const SaImmAttrValuesT_2 * attrValues[] = {&v1, &v2, &v3, &v4, NULL};
safassert(saImmOmCcbInitialize(ownerHandle, 0, &ccbHandle), SA_AIS_OK);
safassert(saImmOmCcbObjectCreate_2(ccbHandle, configClassName, parentName, attrValues), SA_AIS_OK);
safassert(saImmOmCcbApply(ccbHandle), SA_AIS_OK);
return saImmOmCcbFinalize(ccbHandle);
}
static void ccb_create_obj(SaNameT* parentDn, SaNameT* rdnVal, SaImmCcbHandleT ccbHandle,
const SaImmClassNameT className, SaImmAttrNameT rdnAttName, SaImmValueTypeT rdnAttType)
{
unsigned int retries=0;
SaAisErrorT err = SA_AIS_OK;
SaImmAttrValueT theValue;
SaStringT str = (SaStringT) rdnVal->value;
if (rdnAttType == SA_IMM_ATTR_SANAMET) {
theValue = rdnVal;
} else {
assert(rdnAttType == SA_IMM_ATTR_SASTRINGT);
theValue = &str;
}
SaImmAttrValuesT_2 v1 = {rdnAttName, rdnAttType, 1, &theValue};
const SaImmAttrValuesT_2 * attrValues[] = {&v1, NULL};
do {
err = saImmOmCcbObjectCreate_2(ccbHandle, className, parentDn, attrValues);
if (err == SA_AIS_ERR_TRY_AGAIN) {
usleep(250 * 1000);
}
} while ((err == SA_AIS_ERR_TRY_AGAIN) && (retries < 15));
if (err != SA_AIS_OK) {
if ((err == SA_AIS_ERR_NOT_EXIST) && ccb_safe) {
fprintf(stderr, "Missing: implementer, or object, or attribute "
"(see immcfg -h under '--unsafe')\n");
}
fprintf(stderr, "error - Failed to create object parent%s rdn:%s error:%u\n",
(parentDn && parentDn->length)?(char *) parentDn->value:NULL,
(rdnVal->length)?(char *) rdnVal->value:NULL, err);
exit(1);
}
}
SaAisErrorT object_create_2(SaImmHandleT immHandle,
SaImmCcbHandleT ccbHandle,
const SaImmClassNameT className,
const SaNameT *rdnObj,
const SaNameT *parentName,
const SaImmAttrValuesT_2 *value)
{
SaAisErrorT err;
const SaNameT* nameValues[] = {rdnObj, NULL};
SaImmAttrValuesT_2 v = {NULL, SA_IMM_ATTR_SANAMET, 1, (void**)nameValues};
const SaImmAttrValuesT_2 * attrValues[] = {&v, value, NULL};
SaImmClassCategoryT category;
SaImmAttrDefinitionT_2 **attrDefinition;
err = saImmOmClassDescriptionGet_2(immHandle, className, &category, &attrDefinition);
if(err != SA_AIS_OK) {
return err;
}
int i = 0;
while(attrDefinition[i]) {
if(attrDefinition[i]->attrFlags & SA_IMM_ATTR_RDN) {
v.attrName = attrDefinition[i]->attrName;
break;
}
i++;
}
assert(attrDefinition[i]);
err = saImmOmCcbObjectCreate_2(ccbHandle, className, parentName, attrValues);
safassert(saImmOmClassDescriptionMemoryFree_2(immHandle, attrDefinition), SA_AIS_OK);
return err;
}
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);
}
