SaAisErrorT config_class_create(SaImmHandleT immHandle)
{
SaAisErrorT err=SA_AIS_OK;
SaImmAttrDefinitionT_2 rdn = {
"rdn", SA_IMM_ATTR_SANAMET, SA_IMM_ATTR_CONFIG | SA_IMM_ATTR_RDN,
NULL
};
SaImmAttrDefinitionT_2 attr1 = {
"attr1", SA_IMM_ATTR_SAUINT32T, SA_IMM_ATTR_CONFIG | SA_IMM_ATTR_WRITABLE,
NULL};
SaImmAttrDefinitionT_2 attr2 = {
"attr2", SA_IMM_ATTR_SAUINT32T, SA_IMM_ATTR_RUNTIME, NULL};
const SaImmAttrDefinitionT_2* attributes[] = {&rdn, &attr1, &attr2, NULL};
err = saImmOmClassCreate_2(immHandle, configClassName, SA_IMM_CLASS_CONFIG,
attributes);
if((err == SA_AIS_OK) || (err == SA_AIS_ERR_EXIST)) {
return SA_AIS_OK;
}
return rc;
}
SaAisErrorT nodangling_class_create(SaImmHandleT immHandle)
{
SaAisErrorT err=SA_AIS_OK;
SaImmAttrDefinitionT_2 rdn = {
"rdn", SA_IMM_ATTR_SANAMET, SA_IMM_ATTR_CONFIG | SA_IMM_ATTR_RDN,
NULL
};
SaImmAttrDefinitionT_2 attr1 = {
"attr1", SA_IMM_ATTR_SANAMET, SA_IMM_ATTR_CONFIG | SA_IMM_ATTR_WRITABLE | SA_IMM_ATTR_NO_DANGLING,
NULL};
SaImmAttrDefinitionT_2 attr2 = {
"attr2", SA_IMM_ATTR_SANAMET, SA_IMM_ATTR_CONFIG | SA_IMM_ATTR_WRITABLE | SA_IMM_ATTR_MULTI_VALUE | SA_IMM_ATTR_NO_DANGLING,
NULL};
const SaImmAttrDefinitionT_2* attributes[] = {&rdn, &attr1, &attr2, NULL};
err = saImmOmClassCreate_2(immHandle, nodanglingClassName, SA_IMM_CLASS_CONFIG,
attributes);
if((err == SA_AIS_OK) || (err == SA_AIS_ERR_EXIST)) {
return SA_AIS_OK;
}
return err;
}
void saImmOmClassDelete_2_01(void)
{
const SaImmClassNameT className = (SaImmClassNameT) __FUNCTION__;
SaImmAttrDefinitionT_2 attr1 =
{"rdn", SA_IMM_ATTR_SANAMET, SA_IMM_ATTR_CONFIG | SA_IMM_ATTR_RDN, NULL};
const SaImmAttrDefinitionT_2 *attrDefinitions[] = {&attr1, NULL};
safassert(saImmOmInitialize(&immOmHandle, &immOmCallbacks, &immVersion), SA_AIS_OK);
safassert(saImmOmClassCreate_2(immOmHandle, className, SA_IMM_CLASS_CONFIG, attrDefinitions), SA_AIS_OK);
rc = saImmOmClassDelete(immOmHandle, className);
test_validate(rc, SA_AIS_OK);
safassert(saImmOmFinalize(immOmHandle), SA_AIS_OK);
}
SaAisErrorT runtime_class_create(SaImmHandleT immHandle)
{
SaImmAttrDefinitionT_2 rdn = {
"rdn", SA_IMM_ATTR_SANAMET, SA_IMM_ATTR_RUNTIME | SA_IMM_ATTR_RDN | SA_IMM_ATTR_CACHED,
NULL
};
SaImmAttrDefinitionT_2 attr1 = {
"attr1", SA_IMM_ATTR_SAUINT32T, SA_IMM_ATTR_RUNTIME, NULL};
const SaImmAttrDefinitionT_2* attributes[] = {&rdn, &attr1, NULL};
return saImmOmClassCreate_2(immHandle, runtimeClassName, SA_IMM_CLASS_RUNTIME,
attributes);
}
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);
}
void saImmOmClassDescriptionGet_2_02(void)
{
const SaImmClassNameT className = (SaImmClassNameT) __FUNCTION__;
SaImmAttrDefinitionT_2 attr1 =
{"rdn", SA_IMM_ATTR_SANAMET, SA_IMM_ATTR_RUNTIME | SA_IMM_ATTR_RDN | SA_IMM_ATTR_CACHED, NULL};
const SaImmAttrDefinitionT_2 *attrDefinitionsIn[] = {&attr1, NULL};
SaImmClassCategoryT classCategory;
SaImmAttrDefinitionT_2** attrDefinitionsOut;
safassert(saImmOmInitialize(&immOmHandle, &immOmCallbacks, &immVersion), SA_AIS_OK);
safassert(saImmOmClassCreate_2(immOmHandle, className, SA_IMM_CLASS_RUNTIME, attrDefinitionsIn), SA_AIS_OK);
rc = saImmOmClassDescriptionGet_2(-1, className, &classCategory, &attrDefinitionsOut);
test_validate(rc, SA_AIS_ERR_BAD_HANDLE);
safassert(saImmOmClassDelete(immOmHandle, className), SA_AIS_OK);
safassert(saImmOmFinalize(immOmHandle), SA_AIS_OK);
}
static void saImmOmLongDn_01(void) {
SaImmHandleT immHandle;
SaAisErrorT error;
SaNameT defaultValue;
SaImmAttrDefinitionT_2 rdn = {
"rdn", SA_IMM_ATTR_SANAMET, SA_IMM_ATTR_CONFIG | SA_IMM_ATTR_RDN, NULL
};
SaImmAttrDefinitionT_2 attr = {
"attr", SA_IMM_ATTR_SANAMET, SA_IMM_ATTR_CONFIG | SA_IMM_ATTR_WRITABLE, &defaultValue
};
const SaImmAttrDefinitionT_2* attributes[] = {&rdn, &attr, NULL};
safassert(saImmOmInitialize(&immHandle, NULL, &immVersion), SA_AIS_OK);
osaf_extended_name_lend(longDn, &defaultValue);
error = saImmOmClassCreate_2(immHandle, "LongDnClass", SA_IMM_CLASS_CONFIG, attributes);
safassert(saImmOmClassDelete(immHandle, "LongDnClass"), SA_AIS_OK);
safassert(saImmOmFinalize(immHandle), SA_AIS_OK);
test_validate(error, SA_AIS_OK);
}
SaAisErrorT config_class_create(SaImmHandleT immHandle)
{
SaAisErrorT err=SA_AIS_OK;
SaImmAttrDefinitionT_2 rdn = {
"rdn", SA_IMM_ATTR_SANAMET, SA_IMM_ATTR_CONFIG | SA_IMM_ATTR_RDN,
NULL
};
SaImmAttrDefinitionT_2 attr1 = {
"attr1", SA_IMM_ATTR_SAUINT32T, SA_IMM_ATTR_CONFIG | SA_IMM_ATTR_WRITABLE,
NULL};
SaImmAttrDefinitionT_2 attr2 = {
"attr2", SA_IMM_ATTR_SAUINT32T, SA_IMM_ATTR_RUNTIME, NULL};
SaImmAttrDefinitionT_2 attr3 = {
"attr3", SA_IMM_ATTR_SASTRINGT, SA_IMM_ATTR_CONFIG | SA_IMM_ATTR_WRITABLE | SA_IMM_ATTR_MULTI_VALUE, NULL};
SaImmAttrDefinitionT_2 attr4 = {
"attr4", SA_IMM_ATTR_SASTRINGT, SA_IMM_ATTR_CONFIG | SA_IMM_ATTR_WRITABLE, NULL};
SaImmAttrDefinitionT_2 attr5 = {
"attr5", SA_IMM_ATTR_SAANYT, SA_IMM_ATTR_CONFIG | SA_IMM_ATTR_WRITABLE, NULL};
SaImmAttrDefinitionT_2 attr6 = {
"attr6", SA_IMM_ATTR_SAANYT, SA_IMM_ATTR_CONFIG | SA_IMM_ATTR_WRITABLE | SA_IMM_ATTR_MULTI_VALUE, NULL};
SaImmAttrDefinitionT_2 attr7 = {
"attr7", SA_IMM_ATTR_SAANYT, SA_IMM_ATTR_CONFIG | SA_IMM_ATTR_WRITABLE | SA_IMM_ATTR_MULTI_VALUE | SA_IMM_ATTR_NO_DUPLICATES, NULL};
const SaImmAttrDefinitionT_2* attributes[] = {&rdn, &attr1, &attr2, &attr3, &attr4, &attr5, &attr6, &attr7, NULL};
err = saImmOmClassCreate_2(immHandle, configClassName, SA_IMM_CLASS_CONFIG,
attributes);
if((err == SA_AIS_OK) || (err == SA_AIS_ERR_EXIST)) {
return SA_AIS_OK;
}
return err;
}
static void saImmOmLongDn_02(void) {
SaImmHandleT immHandle;
SaAisErrorT error;
SaNameT defaultValue;
SaImmClassCategoryT classCategory;
SaImmAttrDefinitionT_2 rdn = {
"rdn", SA_IMM_ATTR_SANAMET, SA_IMM_ATTR_CONFIG | SA_IMM_ATTR_RDN, NULL
};
SaImmAttrDefinitionT_2 attr = {
"attr", SA_IMM_ATTR_SANAMET, SA_IMM_ATTR_CONFIG | SA_IMM_ATTR_WRITABLE, &defaultValue
};
const SaImmAttrDefinitionT_2* attributes[] = {&rdn, &attr, NULL};
SaImmAttrDefinitionT_2 **attrDef;
safassert(saImmOmInitialize(&immHandle, NULL, &immVersion), SA_AIS_OK);
osaf_extended_name_lend(longDn, &defaultValue);
safassert(saImmOmClassCreate_2(immHandle, "LongDnClass", SA_IMM_CLASS_CONFIG, attributes), SA_AIS_OK);
error = saImmOmClassDescriptionGet_2(immHandle, "LongDnClass", &classCategory, &attrDef);
if(error == SA_AIS_OK) {
int i = 0;
while(attrDef[i]) {
if(!strcmp("attr", attrDef[i]->attrName)) {
SaNameT *testDn = (SaNameT *)attrDef[i]->attrDefaultValue;
assert(testDn != NULL);
assert(strcmp(longDn, osaf_extended_name_borrow(testDn)) == 0);
break;
}
i++;
}
assert(attrDef[i] != NULL);
safassert(saImmOmClassDescriptionMemoryFree_2(immHandle, attrDef), SA_AIS_OK);
}
safassert(saImmOmClassDelete(immHandle, "LongDnClass"), SA_AIS_OK);
safassert(saImmOmFinalize(immHandle), SA_AIS_OK);
test_validate(error, SA_AIS_OK);
}
static PyObject *
immom_saImmOmClassCreate(PyObject *self, PyObject *args)
{
char* className;
char* categoryStr;
SaImmClassCategoryT classCategory;
PyObject* alist;
unsigned int len, i;
SaImmAttrDefinitionT_2** attrDefinitions;
SaAisErrorT rc;
if (!PyArg_ParseTuple(args, "ssO", &className, &categoryStr, &alist))
return NULL;
if (!PyList_Check(alist))
return immom_aisException(SA_AIS_ERR_INVALID_PARAM);
if (strcmp(categoryStr, "CONFIG") == 0) {
classCategory = SA_IMM_CLASS_CONFIG;
} else if (strcmp(categoryStr, "RUNTIME") == 0) {
classCategory = SA_IMM_CLASS_RUNTIME;
} else {
return immom_aisException(SA_AIS_ERR_INVALID_PARAM);
}
len = PyList_Size(alist);
attrDefinitions = (SaImmAttrDefinitionT_2**)
memget(sizeof(SaImmAttrDefinitionT_2*) * (len+1));
attrDefinitions[len] = NULL;
for (i = 0; i < len; i++) {
PyObject* item = PyList_GetItem(alist, i);
char* attrName;
char* attrType;
unsigned PY_LONG_LONG flags;
PyObject* def;
SaImmAttrDefinitionT_2* ad;
if (!PyTuple_Check(item))
return immom_aisException(SA_AIS_ERR_INVALID_PARAM);
if (!PyArg_ParseTuple(item, "ssKO", &attrName, &attrType, &flags,&def))
return immom_return_null();
if (!PyList_Check(def))
return immom_aisException(SA_AIS_ERR_INVALID_PARAM);
ad = (SaImmAttrDefinitionT_2*)memget(sizeof(SaImmAttrDefinitionT_2));
ad->attrName = attrName;
ad->attrValueType = immom_parseTypeStr(attrType);
if ((int)ad->attrValueType == 0)
return immom_aisException(SA_AIS_ERR_INVALID_PARAM);
ad->attrFlags = flags;
ad->attrDefaultValue = NULL;
if (PyList_Size(def) > 0) {
SaImmAttrValuesT_2* attr = memget(sizeof(SaImmAttrValuesT_2));
if (immom_parseAttrValue(attr, attrName, attrType, def)== NULL)
immom_return_null();
ad->attrDefaultValue = attr->attrValues[0];
}
attrDefinitions[i] = ad;
}
rc = saImmOmClassCreate_2(
immOmHandle, className, classCategory,
(const SaImmAttrDefinitionT_2**)attrDefinitions);
if (rc != SA_AIS_OK) return immom_aisException(rc);
return immom_return_None();
}
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);
}
