void saImmOmClassDescriptionGet_2_03(void)
{
const SaImmClassNameT className = (SaImmClassNameT) __FUNCTION__;
SaImmClassCategoryT classCategory;
SaImmAttrDefinitionT_2** attrDefinitionsOut;
safassert(saImmOmInitialize(&immOmHandle, &immOmCallbacks, &immVersion), SA_AIS_OK);
rc = saImmOmClassDescriptionGet_2(immOmHandle, className, &classCategory, &attrDefinitionsOut);
test_validate(rc, SA_AIS_ERR_NOT_EXIST);
safassert(saImmOmFinalize(immOmHandle), SA_AIS_OK);
}
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 PyObject *
immom_saImmOmClassDescriptionGet(PyObject *self, PyObject *args)
{
SaImmClassCategoryT classCategory;
SaImmAttrDefinitionT_2 **attrDefinitions;
char* className;
SaAisErrorT rc;
PyObject* rtuple;
PyObject* alist;
SaImmAttrDefinitionT_2 **ap;
if (!PyArg_ParseTuple(args, "s", &className))
return NULL;
rc = saImmOmClassDescriptionGet_2(
immOmHandle, className, &classCategory, &attrDefinitions);
if (rc != SA_AIS_OK) return immom_aisException(rc);
if (classCategory == SA_IMM_CLASS_CONFIG) {
rtuple = Py_BuildValue("(s[])", "CONFIG");
} else {
rtuple = Py_BuildValue("(s[])", "RUNTIME");
}
alist = PyTuple_GetItem(rtuple, 1);
for (ap = attrDefinitions; *ap != NULL; ap++) {
SaImmAttrDefinitionT_2* a = *ap;
PyObject* atuple = Py_BuildValue(
"(ssK[])", a->attrName, valuetype2str(a->attrValueType),
a->attrFlags);
if (a->attrDefaultValue != NULL) {
SaImmAttrValueT va[1];
SaImmAttrValuesT_2 v;
v.attrValueType = a->attrValueType;
v.attrValuesNumber = 1;
v.attrValues = va;
va[0] = a->attrDefaultValue;
(void)immom_makeValueList(&v, PyTuple_GetItem(atuple,3));
}
if (PyList_Append(alist, atuple) < 0) return NULL;
}
saImmOmClassDescriptionMemoryFree_2(immOmHandle, attrDefinitions);
return rtuple;
}
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);
}
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;
}
/**
* Get name of rdn attribute from IMM
*
* Note:
* A valid ntf_cb.immOmHandle must exist
* Uses in file global struct s_get_rdn_attr_name
*
* @param className[in]
*
* @return String with name
*/
static char *get_rdn_attr_name(const SaImmClassNameT className)
{
SaAisErrorT rc;
int msecs_waited;
int i = 0;
SaImmClassCategoryT classCategory;
SaImmAttrDefinitionT_2 **attrDescr;
TRACE_ENTER();
/* Just return the name if already looked up */
if (strcmp(className, s_get_rdn_attr_name.saved_className) == 0) {
goto done;
}
strncpy(s_get_rdn_attr_name.saved_className, className, SA_MAX_NAME_LENGTH-1);
/* Get class description */
msecs_waited = 0;
rc = saImmOmClassDescriptionGet_2(ntfimcn_cb.immOmHandle,
className,
&classCategory,
&attrDescr);
while ((rc == SA_AIS_ERR_TRY_AGAIN) && (msecs_waited < max_waiting_time_7s)) {
usleep(sleep_delay_ms * 1000);
msecs_waited += sleep_delay_ms;
rc = saImmOmClassDescriptionGet_2(ntfimcn_cb.immOmHandle,
className,
&classCategory,
&attrDescr);
}
if (rc != SA_AIS_OK) {
LOG_ER("saImmOmClassDescriptionGet_2 failed %s", saf_error(rc));
goto error;
}
/* Find the name of the attribute with the RDN flag set */
s_get_rdn_attr_name.attrName[0] = '\0';
for (i=0; attrDescr[i] != NULL; i++) {
if (attrDescr[i]->attrFlags & SA_IMM_ATTR_RDN) {
strncpy(s_get_rdn_attr_name.attrName,attrDescr[i]->attrName,SA_MAX_NAME_LENGTH);
s_get_rdn_attr_name.attrName[SA_MAX_NAME_LENGTH-1] = '\0';
break;
}
}
/* Free memory allocated for attribute descriptions */
msecs_waited = 0;
rc = saImmOmClassDescriptionMemoryFree_2(ntfimcn_cb.immOmHandle,attrDescr);
while ((rc == SA_AIS_ERR_TRY_AGAIN) && (msecs_waited < max_waiting_time_7s)) {
usleep(sleep_delay_ms * 1000);
msecs_waited += sleep_delay_ms;
rc = saImmOmClassDescriptionMemoryFree_2(ntfimcn_cb.immOmHandle,attrDescr);
}
if (rc != SA_AIS_OK) {
LOG_ER("saImmOmClassDescriptionMemoryFree_2 failed %s", saf_error(rc));
goto error;
}
done:
TRACE_LEAVE();
return s_get_rdn_attr_name.attrName;
error:
osafassert(0);
return 0; /* Dummy */
}
static int populate_imm(const SaImmClassNameT className,
unsigned int pop, SaImmAdminOwnerHandleT ownerHandle, SaImmHandleT immHandle)
{
SaAisErrorT error;
int i;
int rc = EXIT_FAILURE;
SaImmCcbHandleT ccbHandle;
SaImmClassCategoryT classCategory;
SaImmAttrDefinitionT_2 **attrDefinitions;
SaImmAttrDefinitionT_2 *att;
SaImmAttrNameT rdnAttName = NULL;
SaImmValueTypeT rdnAttType = SA_IMM_ATTR_SAANYT;
range_obj_t *rootObj = NULL;
if ((error = saImmOmClassDescriptionGet_2(immHandle, className, &classCategory, &attrDefinitions)) != SA_AIS_OK) {
fprintf(stderr, "error - saImmOmClassDescriptionGet_2 FAILED: %s\n", saf_error(error));
goto done;
}
if (classCategory == SA_IMM_CLASS_RUNTIME) {
fprintf(stderr, "error - Class %s is a runtime class\n", className);
goto done;
}
for (i = 0, att = attrDefinitions[i]; att != NULL; att = attrDefinitions[++i]) {
if (att->attrFlags & SA_IMM_ATTR_RDN) {
rdnAttName = att->attrName;
rdnAttType = att->attrValueType;
} else if (att->attrFlags & SA_IMM_ATTR_INITIALIZED) {
fprintf(stderr, "error - Attribute %s has INITIALIZED flag, cant handle\n", att->attrName);
goto done;
}
VERBOSE_INFO("attrName: %s\n", att->attrName);
}
if (!rdnAttName) {
fprintf(stderr, "error - Could not find any RDN attribure\n");
goto done;
}
VERBOSE_INFO("Rdn attrName:%s type:%s\n", rdnAttName, (rdnAttType==SA_IMM_ATTR_SASTRINGT)?"SA_STRINGT":
(rdnAttType==SA_IMM_ATTR_SANAMET)?"SA_NAMET":"WRONG");
if ((error = saImmOmCcbInitialize(ownerHandle, (ccb_safe ? SA_IMM_CCB_REGISTERED_OI : 0x0), &ccbHandle))
!= SA_AIS_OK) {
fprintf(stderr, "error - saImmOmCcbInitialize FAILED: %s\n", saf_error(error));
goto done;
}
VERBOSE_INFO("className: %s po:%u\n", className, pop);
rootObj = gen_pop_tree(0, NULL, 0, 1, pop, rdnAttName);
ccb_create_obj(NULL, &rootObj->parentDn, ccbHandle, className, rdnAttName, rdnAttType);
generate_pop(rootObj, ccbHandle, className, rdnAttName, rdnAttType, ownerHandle);
if ((error = saImmOmCcbFinalize(ccbHandle)) != SA_AIS_OK) {
fprintf(stderr, "error - saImmOmCcbFinalize FAILED: %s\n", saf_error(error));
goto done;
}
rc = 0;
done:
return rc;
}
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);
}
