/*
* Create objects for the static AMF entities.
*/
ClRcT corAmfTreeInitialize(void)
{
ClRcT rc = CL_OK;
if(gClAmfMibLoaded)
{
rc = corAmfMibTreeInitialize();
}
else
{
ClVersionT version = {'B', 0x1 , 0x1};
ClCorMOIdT moId;
ClAmsEntityBufferT nodeList = {0};
ClAmsEntityBufferT suList = {0};
ClAmsEntityBufferT compList = {0};
ClAmsEntityBufferT sgList = {0};
ClAmsEntityBufferT siList = {0};
ClAmsEntityBufferT csiList = {0};
ClCorClassTypeT classIds[CL_AMS_ENTITY_TYPE_MAX+2] = {0};
ClCorMOClassPathT sgClassPath;
ClInt32T i;
rc = corAmfEntityInitialize();
if(rc != CL_OK) goto out;
rc = clAmsMgmtInitialize(&mgmtHandle, NULL, &version);
if(rc != CL_OK)
{
clLogError("COR", "AMF", "Mgmt initialize returned [%#x]", rc);
goto out;
}
if( (rc = clAmsMgmtGetNodeList(mgmtHandle, &nodeList)) != CL_OK)
{
clLogError("COR", "AMF", "Node list returned [%#x]", rc);
goto out;
}
/*
* Create object heirarchy for nodes/sus/comps.
*/
for(i = 0; i < nodeList.count; ++i)
{
ClInt32T j;
ClCorMOClassPathT nodeClassPath;
rc = clCorMoIdInitialize(&moId);
CL_ASSERT(rc == CL_OK);
rc = clCorNodeNameToMoIdGet(nodeList.entity[i].name, &moId);
if(rc != CL_OK)
{
clLogError("COR", "AMF", "Node name to moid get for [%s] failed with [%#x]",
nodeList.entity[i].name.value, rc);
goto out;
}
rc = clCorMoClassPathInitialize(&nodeClassPath);
CL_ASSERT(rc == CL_OK);
rc = clCorMoIdToMoClassPathGet(&moId, &nodeClassPath);
CL_ASSERT(rc == CL_OK);
/*
* Now get nodes su list.
*/
rc = clAmsMgmtGetNodeSUList(mgmtHandle, &nodeList.entity[i], &suList);
if(rc != CL_OK)
{
clLogError("COR", "AMF", "Node [%s] su list returned [%#x]",
nodeList.entity[i].name.value, rc);
goto out;
}
if(!classIds[CL_AMS_ENTITY_TYPE_SU])
{
rc = corAmfEntityClassGet(CL_AMS_ENTITY_TYPE_SU, classIds+CL_AMS_ENTITY_TYPE_SU);
if(rc != CL_OK)
{
clLogError("COR", "AMF", "Class for entity SU not found");
goto out;
}
}
if(!classIds[CL_AMS_ENTITY_TYPE_COMP])
{
rc = corAmfEntityClassGet(CL_AMS_ENTITY_TYPE_COMP, classIds+CL_AMS_ENTITY_TYPE_COMP);
if(rc != CL_OK)
{
clLogError("COR", "AMF", "Class for entity comp not found");
goto out;
}
}
rc = clCorMoClassPathAppend(&nodeClassPath, classIds[CL_AMS_ENTITY_TYPE_SU]);
CL_ASSERT(rc == CL_OK);
rc = corAmfMoClassCreate("AMFSu", &nodeClassPath, NULL);
if(rc != CL_OK)
{
if(CL_GET_ERROR_CODE(rc) != CL_COR_MO_TREE_ERR_FAILED_TO_ADD_NODE)
goto out;
}
if(CL_GET_ERROR_CODE(rc) != CL_COR_MO_TREE_ERR_FAILED_TO_ADD_NODE)
{
rc = clCorMoClassPathAppend(&nodeClassPath, classIds[CL_AMS_ENTITY_TYPE_COMP]);
CL_ASSERT(rc == CL_OK);
rc = corAmfMoClassCreate("AMFComp", &nodeClassPath, NULL);
if(rc != CL_OK) goto out;
}
else
{
rc = CL_OK;
}
for(j = 0; j < suList.count; ++j)
{
ClInt32T k;
ClCorMOIdT suMoId;
memcpy(&suMoId, &moId, sizeof(suMoId));
rc = clCorMoIdAppend(&suMoId, classIds[CL_AMS_ENTITY_TYPE_SU], j);
CL_ASSERT(rc == CL_OK);
rc = corAmfObjectCreate(0, &suList.entity[j], &suMoId);
if(rc != CL_OK) goto out;
rc = clAmsMgmtGetSUCompList(mgmtHandle, &suList.entity[j], &compList);
if(rc != CL_OK)
{
goto out;
}
for(k = 0; k < compList.count; ++k)
{
ClCorMOIdT compMoId;
memcpy(&compMoId, &suMoId, sizeof(compMoId));
rc = clCorMoIdAppend(&compMoId, classIds[CL_AMS_ENTITY_TYPE_COMP], k);
CL_ASSERT(rc == CL_OK);
rc = corAmfObjectCreate(0, &compList.entity[k], &compMoId);
if(rc != CL_OK) goto out;
}
clHeapFree(compList.entity);
compList.entity = NULL;
}
clHeapFree(suList.entity);
suList.entity = NULL;
}
/*
* Configure object heirarchy for SGs.
*/
rc = clAmsMgmtGetSGList(mgmtHandle, &sgList);
if(rc != CL_OK)
{
clLogError("COR", "AMF", "SG list returned [%#x]", rc);
goto out;
}
rc = corAmfEntityClassGet(CL_AMS_ENTITY_TYPE_SG, &classIds[CL_AMS_ENTITY_TYPE_SG]);
if(rc != CL_OK)
{
clLogError("COR", "AMF", "SG entity class not found");
goto out;
}
rc = corAmfEntityClassGet(CL_AMS_ENTITY_TYPE_SG, &classIds[CL_AMS_ENTITY_TYPE_SI]);
if(rc != CL_OK)
{
clLogError("COR", "AMF", "SI entity class not found");
goto out;
}
rc = corAmfEntityClassGet(CL_AMS_ENTITY_TYPE_SG, &classIds[CL_AMS_ENTITY_TYPE_CSI]);
if(rc != CL_OK)
{
clLogError("COR", "AMF", "CSI entity class not found");
goto out;
}
rc = clCorMoClassPathInitialize(&sgClassPath);
CL_ASSERT(rc == CL_OK);
rc = clCorMoClassPathAppend(&sgClassPath, classIds[CL_AMS_ENTITY_TYPE_SG]);
CL_ASSERT(rc == CL_OK);
rc = corAmfMoClassCreate("AMFSg", &sgClassPath, NULL);
if(rc != CL_OK) goto out;
rc = clCorMoClassPathAppend(&sgClassPath, classIds[CL_AMS_ENTITY_TYPE_SI]);
CL_ASSERT(rc == CL_OK);
rc = corAmfMoClassCreate("AMFSi", &sgClassPath, NULL);
if(rc != CL_OK) goto out;
rc = clCorMoClassPathAppend(&sgClassPath, classIds[CL_AMS_ENTITY_TYPE_CSI]);
CL_ASSERT(rc == CL_OK);
rc = corAmfMoClassCreate("AMFCsi", &sgClassPath, NULL);
if(rc != CL_OK) goto out;
for(i = 0; i < sgList.count; ++i)
{
ClInt32T j;
rc = clCorMoIdInitialize(&moId);
CL_ASSERT(rc == CL_OK);
rc = clCorMoIdAppend(&moId, classIds[CL_AMS_ENTITY_TYPE_SG], i);
CL_ASSERT(rc == CL_OK);
rc = corAmfObjectCreate(0, &sgList.entity[i], &moId);
if(rc != CL_OK) goto out;
rc = clAmsMgmtGetSGSIList(mgmtHandle, &sgList.entity[i], &siList);
if(rc != CL_OK)
{
clLogError("COR", "AMF", "SI list get for SG [%s] returned [%#x]",
sgList.entity[i].name.value, rc);
goto out;
}
for(j = 0; j < siList.count; ++j)
{
ClInt32T k;
ClCorMOIdT siMoId;
memcpy(&siMoId, &moId, sizeof(siMoId));
rc = clCorMoIdAppend(&siMoId, classIds[CL_AMS_ENTITY_TYPE_SI], j);
CL_ASSERT(rc == CL_OK);
rc = corAmfObjectCreate(0, &siList.entity[j], &siMoId);
if(rc != CL_OK) goto out;
rc = clAmsMgmtGetSICSIList(mgmtHandle, &siList.entity[j], &csiList);
if(rc != CL_OK)
{
clLogError("COR", "AMF", "CSI list for SI [%s] returned [%#x]",
siList.entity[j].name.value, rc);
goto out;
}
for(k = 0; k < csiList.count; ++k)
{
ClCorMOIdT csiMoId;
memcpy(&csiMoId, &siMoId, sizeof(csiMoId));
rc = clCorMoIdAppend(&csiMoId, classIds[CL_AMS_ENTITY_TYPE_CSI], k);
CL_ASSERT(rc == CL_OK);
rc = corAmfObjectCreate(0, &csiList.entity[k], &csiMoId);
if(rc != CL_OK) goto out;
}
clHeapFree(csiList.entity);
csiList.entity = NULL;
}
clHeapFree(siList.entity);
siList.entity = NULL;
}
/*
* We are here when the objects are all created. Do a commit
*/
rc = corAmfObjectCommit();
if(rc != CL_OK)
{
clLogError("COR", "AMF", "Object commit returned [%#x]", rc);
goto out;
}
clLogNotice("COR", "AMF", "COR AMF tree successfully initialized");
out:
if(nodeList.entity)
clHeapFree(nodeList.entity);
if(suList.entity)
clHeapFree(suList.entity);
if(compList.entity)
clHeapFree(compList.entity);
if(sgList.entity)
clHeapFree(sgList.entity);
if(siList.entity)
clHeapFree(siList.entity);
if(csiList.entity)
clHeapFree(csiList.entity);
}
return rc;
}
ClRcT corAmfMibTreeInitialize(void)
{
ClRcT rc = CL_OK;
ClVersionT version = {'B', 0x1 , 0x1};
ClCorMOIdT moId;
ClCorMOIdT chassisMoid;
ClAmsEntityBufferT nodeList = {0};
ClAmsEntityBufferT suList = {0};
ClAmsEntityBufferT compList = {0};
ClAmsEntityBufferT sgList = {0};
ClAmsEntityBufferT siList = {0};
ClAmsEntityBufferT csiList = {0};
ClCorClassTypeT classIds[CL_AMS_ENTITY_TYPE_MAX+2] = {0};
ClInt32T chassisId = 0;
ClNameT entityName = {0};
ClUint32T i = 0;
static ClUint32T extendedIndexTable[CL_AMS_MGMT_OI_EXTENDED_CLASS_MAX];
rc = corAmfEntityInitialize();
if(rc != CL_OK) goto out;
rc = clAmsMgmtInitialize(&mgmtHandle, NULL, &version);
if(rc != CL_OK)
{
clLogError("COR", "AMF", "Mgmt initialize returned [%#x]", rc);
goto out;
}
snprintf(entityName.value, sizeof(entityName.value), "%s:%d", "\\Chassis", chassisId);
entityName.length = strlen(entityName.value);
rc = clCorMoIdNameToMoIdGet(&entityName, &chassisMoid);
if(rc != CL_OK)
{
clLogError("COR", "AMF", "Cor moid get returned [%#x] for name [%s]",
rc, entityName.value);
goto out;
}
for(i = 0; i <= CL_AMS_ENTITY_TYPE_MAX; ++i)
{
rc = corAmfEntityClassGet(i, classIds + i);
if(rc != CL_OK)
{
clLogError("COR", "AMF", "Entity class for [%s] not found",
CL_AMS_STRING_ENTITY_TYPE(i));
goto out;
}
}
if( (rc = clAmsMgmtGetNodeList(mgmtHandle, &nodeList)) != CL_OK)
{
clLogError("COR", "AMF", "Node list returned [%#x]", rc);
goto out;
}
/*
* Create objects for nodes/sus/comps/sgs/sis/csis
*/
for(i = 0; i < nodeList.count; ++i)
{
memcpy(&moId, &chassisMoid, sizeof(moId));
clCorMoIdAppend(&moId, classIds[CL_AMS_ENTITY_TYPE_NODE], i);
rc = corAmfObjectCreate(i, &nodeList.entity[i], &moId);
if(rc != CL_OK) goto out;
}
rc = clAmsMgmtGetSUList(mgmtHandle, &suList);
if(rc != CL_OK)
{
clLogError("COR", "AMF", "SU list get returned [%#x]", rc);
goto out;
}
for(i = 0; i < suList.count; ++i)
{
memcpy(&moId, &chassisMoid, sizeof(moId));
rc = clCorMoIdAppend(&moId, classIds[CL_AMS_ENTITY_TYPE_SU], i);
CL_ASSERT(rc == CL_OK);
rc = corAmfObjectCreate(i, &suList.entity[i], &moId);
if(rc != CL_OK) goto out;
}
rc = clAmsMgmtGetCompList(mgmtHandle, &compList);
if(rc != CL_OK)
{
clLogError("COR", "AMF", "Comp list get returned [%#x]", rc);
goto out;
}
for(i = 0; i < compList.count; ++i)
{
memcpy(&moId, &chassisMoid, sizeof(moId));
rc = clCorMoIdAppend(&moId, classIds[CL_AMS_ENTITY_TYPE_COMP], i);
CL_ASSERT(rc == CL_OK);
rc = corAmfObjectCreate(i, &compList.entity[i], &moId);
if(rc != CL_OK) goto out;
}
rc = clAmsMgmtGetSGList(mgmtHandle, &sgList);
if(rc != CL_OK)
{
clLogError("COR", "AMF", "SG list returned [%#x]", rc);
goto out;
}
for(i = 0; i < sgList.count; ++i)
{
ClAmsEntityBufferT rankList = {0};
memcpy(&moId, &chassisMoid, sizeof(moId));
rc = clCorMoIdAppend(&moId, classIds[CL_AMS_ENTITY_TYPE_SG], i);
CL_ASSERT(rc == CL_OK);
rc = corAmfObjectCreate(i, &sgList.entity[i], &moId);
if(rc != CL_OK) goto out;
rc = clAmsMgmtGetSGSIList(mgmtHandle, &sgList.entity[i], &rankList);
if(rc != CL_OK)
{
clLogError("COR", "AMF", "SG [%s] si list returned [%#x]",
sgList.entity[i].name.value, rc);
goto out;
}
rc = corAmfExtendedClassObjectCreate("saAmfSGSIRankTable",
&sgList.entity[i],
&chassisMoid,
rankList.count,
&extendedIndexTable[CL_AMS_MGMT_OI_SGSIRANK],
&i);
if(rankList.entity)
{
clHeapFree(rankList.entity);
rankList.entity = NULL;
rankList.count = 0;
}
rc = clAmsMgmtGetSGSUList(mgmtHandle, &sgList.entity[i], &rankList);
if(rc != CL_OK)
{
clLogError("COR", "AMF", "SG [%s] su list returned [%#x]",
sgList.entity[i].name.value, rc);
goto out;
}
rc = corAmfExtendedClassObjectCreate("saAmfSGSURankTable",
&sgList.entity[i],
&chassisMoid,
rankList.count,
&extendedIndexTable[CL_AMS_MGMT_OI_SGSURANK],
&i);
if(rankList.entity)
{
clHeapFree(rankList.entity);
rankList.count = 0;
}
}
rc = clAmsMgmtGetSIList(mgmtHandle, &siList);
if(rc != CL_OK)
{
clLogError("COR", "AMF", "SI list get returned [%#x]", rc);
goto out;
}
for(i = 0; i < siList.count; ++i)
{
ClAmsEntityBufferT list = {0};
memcpy(&moId, &chassisMoid, sizeof(moId));
rc = clCorMoIdAppend(&moId, classIds[CL_AMS_ENTITY_TYPE_SI], i);
CL_ASSERT(rc == CL_OK);
rc = corAmfObjectCreate(i, &siList.entity[i], &moId);
if(rc != CL_OK) goto out;
rc = clAmsMgmtGetSIDependenciesList(mgmtHandle, &siList.entity[i],
&list);
if(rc != CL_OK)
{
clLogError("COR", "AMF", "SI [%s] dependencies list returned [%#x]",
siList.entity[i].name.value, rc);
goto out;
}
if(list.count)
{
rc = corAmfExtendedClassObjectCreate("saAmfSISIDepTable",
&siList.entity[i],
&chassisMoid,
list.count,
&extendedIndexTable[CL_AMS_MGMT_OI_SISIDEP],
&i);
}
if(list.entity)
{
clHeapFree(list.entity);
list.count = 0;
}
rc = clAmsMgmtGetSISURankList(mgmtHandle, &siList.entity[i], &list);
if(rc != CL_OK)
{
clLogError("COR", "AMF", "SI [%s] su rank list returned [%#x]",
siList.entity[i].name.value, rc);
goto out;
}
if(list.count)
{
rc = corAmfExtendedClassObjectCreate("saAmfSUsperSIRankTable",
&siList.entity[i],
&chassisMoid,
list.count,
&extendedIndexTable[CL_AMS_MGMT_OI_SUSPERSIRANK],
&i);
}
if(list.entity)
{
list.count = 0;
clHeapFree(list.entity);
}
}
rc = clAmsMgmtGetCSIList(mgmtHandle, &csiList);
if(rc != CL_OK)
{
clLogError("COR", "AMF", "CSI list get returned [%#x]", rc);
goto out;
}
for(i = 0; i < csiList.count; ++i)
{
ClAmsCSINVPBufferT buffer = {0};
ClAmsEntityBufferT list = {0};
memcpy(&moId, &chassisMoid, sizeof(moId));
rc = clCorMoIdAppend(&moId, classIds[CL_AMS_ENTITY_TYPE_CSI], i);
CL_ASSERT(rc == CL_OK);
rc = corAmfObjectCreate(i, &csiList.entity[i], &moId);
if(rc != CL_OK) goto out;
rc = clAmsMgmtGetCSINVPList(mgmtHandle, &csiList.entity[i], &buffer);
if(rc != CL_OK)
{
clLogError("COR", "AMF", "CSI [%s] nvp list returned [%#x]",
csiList.entity[i].name.value, rc);
goto out;
}
rc = corAmfExtendedClassObjectCreate("saAmfCSINameValueTable",
&csiList.entity[i],
&chassisMoid,
buffer.count,
&extendedIndexTable[CL_AMS_MGMT_OI_CSINAMEVALUE],
&i);
if(buffer.nvp)
{
clHeapFree(buffer.nvp);
}
rc = clAmsMgmtGetCSIDependenciesList(mgmtHandle, &csiList.entity[i],
&list);
if(rc != CL_OK)
{
clLogError("COR", "AMF", "CSI [%s] dependencies list returned [%#x]",
csiList.entity[i].name.value, rc);
goto out;
}
rc = corAmfExtendedClassObjectCreate("saAmfCSICSIDepTable",
&csiList.entity[i],
&chassisMoid,
list.count,
&extendedIndexTable[CL_AMS_MGMT_OI_CSICSIDEP],
&i);
if(list.entity)
{
clHeapFree(list.entity);
}
}
/*
* We are here when the objects are all created. Do a commit
*/
rc = corAmfObjectCommit();
if(rc != CL_OK)
{
clLogError("COR", "AMF", "Object commit returned [%#x]", rc);
goto out;
}
clLogNotice("COR", "AMF", "COR AMF tree successfully initialized");
out:
if(nodeList.entity)
clHeapFree(nodeList.entity);
if(suList.entity)
clHeapFree(suList.entity);
if(compList.entity)
clHeapFree(compList.entity);
if(sgList.entity)
clHeapFree(sgList.entity);
if(siList.entity)
clHeapFree(siList.entity);
if(csiList.entity)
clHeapFree(csiList.entity);
return rc;
}
static ClRcT clAmsMgmtOIExtendedConfigAttributeSet(ClAmsMgmtHandleT handle,
ClCorTxnSessionIdT *pSession,
ClAmsEntityT *pEntity,
ClRcT (*pClAmsMgmtOIExtendedConfigAttributesGet)
(ClAmsMgmtOIExtendedClassTypeT type,
ClAmsMgmtOIExtendedEntityConfigT *pConfig,
ClCorClassTypeT *pClassType,
ClCorAttributeValueListPtrT))
{
ClRcT rc = CL_OK;
if(!handle || !pSession || !pEntity || !pClAmsMgmtOIExtendedConfigAttributesGet)
return CL_AMS_RC(CL_ERR_INVALID_PARAMETER);
switch(pEntity->type)
{
case CL_AMS_ENTITY_TYPE_SG:
{
ClAmsEntityBufferT list = {0};
rc = clAmsMgmtGetSGSUList(handle, pEntity, &list);
if(rc != CL_OK)
{
clLogError("AMF", "MGMT", "SG [%s] SU list returned [%#x]",
pEntity->name.value, rc);
goto out;
}
rc = amsMgmtOIExtendedConfigAttributeSet(CL_AMS_MGMT_OI_SGSURANK,
pSession,
pEntity,
&list,
pClAmsMgmtOIExtendedConfigAttributesGet);
if(list.entity)
{
clHeapFree(list.entity);
list.entity = NULL;
list.count = 0;
}
if(rc != CL_OK)
{
goto out;
}
rc = clAmsMgmtGetSGSIList(handle, pEntity, &list);
if(rc != CL_OK)
{
clLogError("AMF", "MGMT", "SG [ %s] SI list returned [%#x]",
pEntity->name.value, rc);
goto out;
}
rc = amsMgmtOIExtendedConfigAttributeSet(CL_AMS_MGMT_OI_SGSIRANK,
pSession,
pEntity,
&list,
pClAmsMgmtOIExtendedConfigAttributesGet);
if(list.entity)
clHeapFree(list.entity);
if(rc != CL_OK)
goto out;
}
break;
case CL_AMS_ENTITY_TYPE_SI:
{
ClAmsEntityBufferT list = {0};
rc = clAmsMgmtGetSIDependenciesList(handle, pEntity, &list);
if(rc != CL_OK)
{
clLogError("AMF", "MGMT", "SI [%s] dependencies list returned [%#x]",
pEntity->name.value, rc);
goto out;
}
rc = amsMgmtOIExtendedConfigAttributeSet(CL_AMS_MGMT_OI_SISIDEP,
pSession,
pEntity,
&list,
pClAmsMgmtOIExtendedConfigAttributesGet);
if(list.entity)
{
clHeapFree(list.entity);
list.entity = NULL;
list.count = 0;
}
if(rc != CL_OK)
goto out;
rc = clAmsMgmtGetSISURankList(handle, pEntity, &list);
if(rc != CL_OK)
{
clLogError("AMF", "MGMT", "SI [%s] su rank list returned [%#x]",
pEntity->name.value, rc);
goto out;
}
rc = amsMgmtOIExtendedConfigAttributeSet(CL_AMS_MGMT_OI_SUSPERSIRANK,
pSession,
pEntity,
&list,
pClAmsMgmtOIExtendedConfigAttributesGet);
if(list.entity)
clHeapFree(list.entity);
if(rc != CL_OK)
goto out;
}
break;
case CL_AMS_ENTITY_TYPE_CSI:
{
ClAmsEntityBufferT list = {0};
ClAmsCSINVPBufferT buffer = {0};
rc = clAmsMgmtGetCSIDependenciesList(handle,
pEntity,
&list);
if(rc != CL_OK)
{
clLogError("AMF", "MGMT", "CSI [%s] dependencies list get returned [%#x]",
pEntity->name.value, rc);
goto out;
}
rc = amsMgmtOIExtendedConfigAttributeSet(CL_AMS_MGMT_OI_CSICSIDEP,
pSession,
pEntity,
&list,
pClAmsMgmtOIExtendedConfigAttributesGet);
if(list.entity)
{
clHeapFree(list.entity);
list.entity = NULL;
list.count = 0;
}
if(rc != CL_OK)
{
goto out;
}
rc = clAmsMgmtGetCSINVPList(handle, pEntity, &buffer);
if(rc != CL_OK)
{
clLogError("AMF", "MGMT", "CSI [%s] name value list get returned [%#x]",
pEntity->name.value, rc);
goto out;
}
rc = amsMgmtOIExtendedCSINVPAttributeSet(pSession,
pEntity,
&buffer,
pClAmsMgmtOIExtendedConfigAttributesGet);
if(buffer.nvp)
clHeapFree(buffer.nvp);
if(rc != CL_OK)
goto out;
}
break;
default:
break;
}
out:
return rc;
}
static ClRcT clAmsMgmtSGRedundancyModelEstimate(ClAmsSGRedundancyModelT model,
ClAmsEntityT *sgName,
ClUint32T numActiveSUs,
ClUint32T numStandbySUs,
ClInt32T *extraSIs,
ClInt32T *extraSUs,
ClInt32T *extraNodes)
{
ClRcT rc = CL_OK;
ClAmsEntityConfigT *entityConfig = NULL;
ClAmsSGConfigT sgConfig = {{CL_AMS_ENTITY_TYPE_ENTITY}};
ClAmsEntityBufferT suBuffer = {0};
ClAmsEntityBufferT nodeBuffer = {0};
ClAmsEntityBufferT siBuffer = {0};
if(!sgName || !extraSIs || !extraSUs || !extraNodes) return CL_AMS_RC(CL_ERR_INVALID_PARAMETER);
*extraSIs = 0, *extraSUs = 0, *extraNodes = 0;
rc = clAmsMgmtEntityGetConfig(gHandle, sgName, &entityConfig);
if(rc != CL_OK)
{
clLogError("AMS", "MIGRATE", "SG redundancy estimate -get config returned [%#x]", rc);
goto out;
}
memcpy(&sgConfig, entityConfig, sizeof(sgConfig));
clHeapFree(entityConfig);
if(sgConfig.numPrefActiveSUs < numActiveSUs)
{
rc = clAmsMgmtGetSGSIList(gHandle, sgName, &siBuffer);
if(rc != CL_OK)
{
clLogError("AMS", "MIGRATE", "AMS sg si list returned [%#x]", rc);
goto out_free;
}
if(siBuffer.count < numActiveSUs)
{
*extraSIs = numActiveSUs - siBuffer.count;
}
}
rc = clAmsMgmtGetSGSUList(gHandle, sgName, &suBuffer);
if(rc != CL_OK)
{
clLogError("AMS", "MIGRATE", "AMS sg su list returned [%#x]", rc);
goto out_free;
}
if(suBuffer.count < numStandbySUs + numActiveSUs)
{
*extraSUs = (numStandbySUs + numActiveSUs)-suBuffer.count;
*extraSIs *= sgConfig.maxActiveSIsPerSU;
rc = clAmsMgmtGetNodeList(gHandle, &nodeBuffer);
if(rc != CL_OK)
{
clLogError("AMS", "MIGRATE", "AMS get node list returned [%#x]", rc);
goto out_free;
}
if(nodeBuffer.count < numActiveSUs + numStandbySUs)
{
*extraNodes = (numActiveSUs + numStandbySUs) - nodeBuffer.count;
}
}
rc = CL_OK;
out_free:
if(suBuffer.entity) clHeapFree(suBuffer.entity);
if(nodeBuffer.entity) clHeapFree(nodeBuffer.entity);
if(siBuffer.entity) clHeapFree(siBuffer.entity);
out:
return rc;
}
static ClRcT clAmsMgmtSGMigrateMPlusN(ClAmsSGRedundancyModelT model,
ClAmsEntityT *sgName,
const ClCharT *prefix,
ClUint32T numActiveSUs,
ClUint32T numStandbySUs,
ClAmsMgmtMigrateListT *migrateList)
{
ClUint32T i;
ClRcT rc = CL_OK;
ClAmsEntityBufferT siBuffer = {0};
ClAmsEntityBufferT suBuffer = {0};
ClAmsEntityBufferT nodeBuffer = {0};
ClInt32T extraSIs = 0;
ClInt32T extraSUs = 0;
ClInt32T extraNodes = 0;
ClAmsEntityT *nodeList = NULL;
ClAmsEntityT *nodes = NULL;
ClAmsEntityT *sus = NULL;
ClAmsEntityT *comps = NULL;
ClAmsEntityT *sis = NULL;
ClAmsEntityT *csis = NULL;
ClInt32T numNodes = 0;
ClAmsEntityConfigT *pSURefComp = NULL;
ClAmsEntityConfigT *pSGRefSI = NULL;
ClAmsEntityConfigT *pSIRefCSI = NULL;
ClAmsEntityConfigT *pSGConfig = NULL;
ClAmsSGConfigT sgConfig = {{CL_AMS_ENTITY_TYPE_ENTITY}};
ClUint32T numSupportedCSITypes = 0;
SaNameT *pNumSupportedCSITypes = NULL;
ClAmsMgmtCCBHandleT ccbHandle = 0;
ClAmsMgmtMigrateListT *unlockList = NULL;
rc = clAmsMgmtEntityGetConfig(gHandle, sgName, &pSGConfig);
if(rc != CL_OK)
{
clLogError("AMS", "MIGRATE", "SG [%.*s] config get returned [%#x]",
sgName->name.length-1, sgName->name.value, rc);
goto out;
}
memcpy(&sgConfig, pSGConfig, sizeof(sgConfig));
clHeapFree(pSGConfig);
/*
* If scaling down actives, ensure that those many service units are locked.
*/
if(numActiveSUs < sgConfig.numPrefActiveSUs)
{
ClInt32T numShrinkSUs = sgConfig.numPrefActiveSUs - numActiveSUs;
ClAmsEntityBufferT suList = {0};
ClInt32T numOutOfServiceSUs = 0;
rc = clAmsMgmtGetSGSUList(gHandle, sgName, &suList);
if(rc != CL_OK)
{
clLogError("AMS", "MIGRATE", "SG [%.*s] su list returned [%#x]",
sgName->name.length-1, sgName->name.value, rc);
goto out;
}
for(i = 0; i < suList.count; ++i)
{
ClAmsSUConfigT *pSUConfig = NULL;
rc = clAmsMgmtEntityGetConfig(gHandle, suList.entity+i,
(ClAmsEntityConfigT**)&pSUConfig);
if(rc != CL_OK)
{
clHeapFree(suList.entity);
clLogError("AMS", "MIGRATE", "SU [%.*s] get config returned [%#x]",
suList.entity[i].name.length-1, suList.entity[i].name.value, rc);
goto out;
}
if(pSUConfig->adminState == CL_AMS_ADMIN_STATE_LOCKED_A
||
pSUConfig->adminState == CL_AMS_ADMIN_STATE_LOCKED_I)
{
++numOutOfServiceSUs;
}
clHeapFree(pSUConfig);
}
clHeapFree(suList.entity);
if(numOutOfServiceSUs < numShrinkSUs)
{
clLogError("AMS", "MIGRATE", "Expected a minimum of [%d] SUs to be out of service to satisfy SG. "
"redundancy model shrink. Got [%d] out of service", numShrinkSUs,
numOutOfServiceSUs);
rc = CL_AMS_RC(CL_AMS_ERR_INVALID_ENTITY_STATE);
goto out;
}
}
rc = clAmsMgmtSGRedundancyModelEstimate(model, sgName, numActiveSUs, numStandbySUs,
&extraSIs, &extraSUs, &extraNodes);
if(rc != CL_OK)
{
goto out;
}
rc = clAmsMgmtCCBInitialize(gHandle, &ccbHandle);
if(rc != CL_OK)
{
clLogError("AMS", "MIGRATE", "AMS ccb initialize returned [%#x]", rc);
goto out;
}
/*
* Add the existing SI CSI list to the supported list.
*/
rc = clAmsMgmtGetSGSIList(gHandle, sgName, &siBuffer);
if(rc != CL_OK)
{
clLogError("AMS", "MIGRATE", "AMS sg si list returned [%#x]", rc);
goto out;
}
if(siBuffer.count)
{
rc = clAmsMgmtEntityGetConfig(gHandle, siBuffer.entity,
&pSGRefSI);
if(rc != CL_OK)
{
clLogError("AMS", "MIGRATE", "AMS reference si get config returned [%#x]",
rc);
goto out_free;
}
}
for(i = 0; i < siBuffer.count; ++i)
{
ClUint32T j;
ClAmsEntityBufferT csiBuffer = {CL_AMS_ENTITY_TYPE_ENTITY};
ClAmsSIConfigT siConfig = {{CL_AMS_ENTITY_TYPE_ENTITY}};
ClUint64T mask = 0;
memcpy(&siConfig.entity, siBuffer.entity+i,
sizeof(siConfig.entity));
mask |= SI_CONFIG_NUM_STANDBY_ASSIGNMENTS;
siConfig.numStandbyAssignments = numStandbySUs;
if(numActiveSUs > 1)
siConfig.numStandbyAssignments = (numStandbySUs+1)&~1;
siConfig.numStandbyAssignments = CL_MAX(1, siConfig.numStandbyAssignments/
(numActiveSUs?numActiveSUs:1));
/*
* Update the num standby assignments.
*/
rc = clAmsMgmtCCBEntitySetConfig(ccbHandle, &siConfig.entity, mask);
if(rc != CL_OK)
{
clLogError("AMS", "MIGRATE", "SI [%.*s] num standby set returned [%#x]",
siConfig.entity.name.length-1, siConfig.entity.name.value, rc);
}
rc = clAmsMgmtGetSICSIList(gHandle, siBuffer.entity+i,
&csiBuffer);
if(rc != CL_OK)
{
clLogError("AMS", "MIGRATE", "AMS get si csi list returned [%#x]", rc);
goto out_free;
}
pNumSupportedCSITypes = (SaNameT*) clHeapRealloc(pNumSupportedCSITypes, (numSupportedCSITypes+csiBuffer.count)*sizeof(SaNameT));
for(j = 0; j < csiBuffer.count ; ++j)
{
ClAmsEntityConfigT *entityConfig = NULL;
ClAmsCSIConfigT csiConfig = {{CL_AMS_ENTITY_TYPE_ENTITY}};
ClUint32T k;
rc = clAmsMgmtEntityGetConfig(gHandle, csiBuffer.entity+j, &entityConfig);
if(rc != CL_OK)
{
clLogError("AMS", "MIGRATE", "AMS csi get config returned [%#x]", rc);
goto out_free;
}
memcpy(&csiConfig, entityConfig, sizeof(csiConfig));
if(!pSIRefCSI)
{
pSIRefCSI = entityConfig;
}
else
{
clHeapFree(entityConfig);
}
/*
* Search for this csi type in the list to see if its
* already present
*/
for(k = 0; k < numSupportedCSITypes; ++k)
{
if(!memcmp(pNumSupportedCSITypes[k].value,
csiConfig.type.value,
pNumSupportedCSITypes[k].length))
break;
}
if(k == numSupportedCSITypes)
{
memcpy(pNumSupportedCSITypes+numSupportedCSITypes,
&csiConfig.type, sizeof(csiConfig.type));
++numSupportedCSITypes;
}
}
clHeapFree(csiBuffer.entity);
}
if(extraSIs)
{
sis = (ClAmsEntityT*) clHeapCalloc(extraSIs, sizeof(ClAmsEntityT));
CL_ASSERT(sis != NULL);
csis = (ClAmsEntityT*) clHeapCalloc(extraSIs, sizeof(ClAmsEntityT));
for(i = siBuffer.count; i < siBuffer.count + extraSIs; ++i)
{
ClAmsEntityT si ={CL_AMS_ENTITY_TYPE_ENTITY};
ClAmsEntityT csi = {CL_AMS_ENTITY_TYPE_ENTITY};
ClUint64T bitMask = 0;
ClAmsSIConfigT siConfig = {{CL_AMS_ENTITY_TYPE_ENTITY}};
ClAmsCSIConfigT csiConfig = {{CL_AMS_ENTITY_TYPE_ENTITY}};
si.type = CL_AMS_ENTITY_TYPE_SI;
snprintf((ClCharT*)si.name.value, sizeof(si.name.value)-1, "%s_%.*s_SI%d", prefix,
sgName->name.length-1, (const ClCharT*)sgName->name.value, i);
clLogNotice("AMS", "MIGRATE", "Creating SI [%s]", si.name.value);
si.name.length = strlen((const ClCharT*)si.name.value)+1;
rc = clAmsMgmtCCBEntityCreate(ccbHandle, &si);
if(rc != CL_OK)
{
clLogError("AMS", "MIGRATE", "AMS entity create returned [%#x]", rc);
goto out_free;
}
memcpy(&sis[i-siBuffer.count], &si, sizeof(si));
rc = clAmsMgmtCCBSetSGSIList(ccbHandle, sgName, &si);
if(rc != CL_OK)
{
clLogError("AMS", "MIGRATE", "AMS set sg silist returned [%#x]", rc);
goto out_free;
}
if(pSGRefSI)
{
/*
* Set config to the base SI.
*/
bitMask = CL_AMS_CONFIG_ATTR_ALL;
memcpy(&siConfig, pSGRefSI, sizeof(siConfig));
memcpy(&siConfig.entity, &si, sizeof(siConfig.entity));
siConfig.numStandbyAssignments = numStandbySUs;
if(numActiveSUs > 1 )
siConfig.numStandbyAssignments = (numStandbySUs+1)&~1;
siConfig.numStandbyAssignments = CL_MAX(1,siConfig.numStandbyAssignments/
(numActiveSUs?numActiveSUs:1));
siConfig.numCSIs = 1;
siConfig.adminState = CL_AMS_ADMIN_STATE_LOCKED_A;
rc = clAmsMgmtCCBEntitySetConfig(ccbHandle, &siConfig.entity, bitMask);
if(rc != CL_OK)
{
clLogError("AMS", "MIGRATE", "AMS entity set config returned [%#x]", rc);
goto out_free;
}
}
csi.type = CL_AMS_ENTITY_TYPE_CSI;
snprintf((ClCharT*)csi.name.value, sizeof(csi.name.value),
"%s_CSI%d", (const ClCharT*)si.name.value, i-siBuffer.count);
csi.name.length = strlen((const ClCharT*)csi.name.value)+1;
clLogNotice("AMS", "MIGRATE", "Creating CSI [%s]", csi.name.value);
rc = clAmsMgmtCCBEntityCreate(ccbHandle, &csi);
if(rc != CL_OK)
{
clLogError("AMS", "MIGRATE", "AMS csi create returned [%#x]", rc);
goto out_free;
}
memcpy(&csis[i-siBuffer.count], &csi, sizeof(csi));
rc = clAmsMgmtCCBSetSICSIList(ccbHandle, &si, &csi);
if(rc != CL_OK)
{
clLogError("AMS", "MIGRATE", "SET si csi list returned [%#x]", rc);
goto out_free;
}
if(pSIRefCSI)
{
/*
* Load the config. for the base csi type.
*/
memcpy(&csiConfig, pSIRefCSI, sizeof(csiConfig));
memcpy(&csiConfig.entity, &csi, sizeof(csiConfig.entity));
csiConfig.isProxyCSI = CL_FALSE;
memcpy(&csiConfig.type, &csiConfig.entity.name, sizeof(csiConfig.type));
bitMask = CL_AMS_CONFIG_ATTR_ALL;
rc = clAmsMgmtCCBEntitySetConfig(ccbHandle, &csiConfig.entity, bitMask);
if(rc != CL_OK)
{
clLogError("AMS", "MIGRATE", "AMS ref csi set config returned [%#x]", rc);
goto out_free;
}
}
/*
* Add this to the supported list.
*/
pNumSupportedCSITypes = (SaNameT*) clHeapRealloc(pNumSupportedCSITypes, (numSupportedCSITypes+1)*sizeof(SaNameT));
CL_ASSERT(pNumSupportedCSITypes != NULL);
memcpy(pNumSupportedCSITypes+numSupportedCSITypes, &csi.name, sizeof(SaNameT));
++numSupportedCSITypes;
}
}
if(extraNodes)
{
nodes = (ClAmsEntityT*) clHeapCalloc(extraNodes, sizeof(ClAmsEntityT));
CL_ASSERT(nodes != NULL);
rc = clAmsMgmtGetNodeList(gHandle, &nodeBuffer);
if(rc != CL_OK)
{
clLogError("AMS", "MIGRATE", "AMS get node list returned [%#x]", rc);
goto out_free;
}
for(i = nodeBuffer.count ; i < nodeBuffer.count + extraNodes; ++i)
{
ClAmsEntityT node = {CL_AMS_ENTITY_TYPE_ENTITY};
node.type = CL_AMS_ENTITY_TYPE_NODE;
snprintf((ClCharT*) node.name.value, sizeof(node.name.value), "%s_Node%d", prefix, i);
node.name.length = strlen((const ClCharT*) node.name.value) + 1;
clLogNotice("AMS", "MIGRATE", "Creating node [%s]", node.name.value);
rc = clAmsMgmtCCBEntityCreate(ccbHandle, &node);
if(rc != CL_OK)
{
clLogError("AMS", "MIGRATE", "AMS ccb create returned [%#x]", rc);
goto out_free;
}
memcpy(&nodes[i-nodeBuffer.count], &node, sizeof(node));
}
}
rc = clAmsMgmtGetSGSUList(gHandle, sgName, &suBuffer);
if(rc != CL_OK)
{
clLogError("AMS", "MIGRATE", "Get SG su list returned [%#x]", rc);
goto out_free;
}
for(i = 0 ; i < suBuffer.count; ++i)
{
ClUint32T j;
ClAmsEntityBufferT compBuffer=
{
0
}
;
rc = clAmsMgmtGetSUCompList(gHandle, &suBuffer.entity[i],
&compBuffer);
if(rc != CL_OK)
{
clLogError("AMS", "MIGRATE", "Get SU comp list returned [%#x]", rc);
goto out_free;
}
/*
* Get the first component properties.
*/
if(!pSURefComp)
{
rc = clAmsMgmtEntityGetConfig(gHandle, compBuffer.entity,
&pSURefComp);
if(rc != CL_OK)
{
clLogError("AMS", "MIGRATE", "AMS base comp get config returned [%#x]",
rc);
goto out_free;
}
}
/*
* Update all config. with supported csi types.
* and correct comp config whereever appropriate
*/
for(j = 0; j < compBuffer.count; ++j)
{
ClAmsEntityConfigT *entityConfig =NULL;
ClAmsCompConfigT compConfig = {{CL_AMS_ENTITY_TYPE_ENTITY}};
ClUint64T bitMask = 0;
ClUint32T k ;
rc = clAmsMgmtEntityGetConfig(gHandle, compBuffer.entity+j,
&entityConfig);
if(rc != CL_OK)
{
clLogError("AMS", "MIGRATE", "AMS comp get config returned [%#x]", rc);
goto out_free;
}
memcpy(&compConfig, entityConfig, sizeof(compConfig));
clHeapFree(entityConfig);
/*
* update supported CSI type incase of SI additions.
*/
if(extraSIs)
{
bitMask |= COMP_CONFIG_SUPPORTED_CSI_TYPE;
compConfig.pSupportedCSITypes = (SaNameT*) clHeapRealloc(compConfig.pSupportedCSITypes, (compConfig.numSupportedCSITypes + extraSIs)* sizeof(SaNameT));
CL_ASSERT(compConfig.pSupportedCSITypes);
for(k = compConfig.numSupportedCSITypes; k < compConfig.numSupportedCSITypes + extraSIs; ++k)
{
memcpy(compConfig.pSupportedCSITypes+k, &csis[k-compConfig.numSupportedCSITypes].name, sizeof(SaNameT));
}
compConfig.numSupportedCSITypes += extraSIs;
}
bitMask |= COMP_CONFIG_NUM_MAX_STANDBY_CSIS;
/*
* take active to standby ratio
*/
compConfig.numMaxStandbyCSIs = numActiveSUs;
if(numStandbySUs > 1 )
compConfig.numMaxStandbyCSIs = (numActiveSUs+1)&~1;
compConfig.numMaxStandbyCSIs = CL_MAX(1, compConfig.numMaxStandbyCSIs/
(numStandbySUs?numStandbySUs:1));
rc = clAmsMgmtCCBEntitySetConfig(ccbHandle,
&compConfig.entity,
bitMask);
clHeapFree(compConfig.pSupportedCSITypes);
if(rc != CL_OK)
{
clLogError("AMS", "MIGRATE", "AMS entity set config returned [%#x]", rc);
goto out_free;
}
}
clHeapFree(compBuffer.entity);
}
if(extraSUs)
{
sus = (ClAmsEntityT*) clHeapCalloc(extraSUs, sizeof(ClAmsEntityT));
CL_ASSERT(sus != NULL);
comps = (ClAmsEntityT*) clHeapCalloc(extraSUs, sizeof(ClAmsEntityT));
CL_ASSERT(comps != NULL);
nodeList = (ClAmsEntityT*) clHeapCalloc(extraSUs + extraNodes, sizeof(ClAmsEntityT));
CL_ASSERT(nodeList != NULL);
rc = clAmsMgmtGetSUFreeNodes(sgName, prefix, extraSUs, extraNodes, nodeList, &numNodes);
for(i = suBuffer.count; i < suBuffer.count + extraSUs; ++i)
{
ClAmsEntityT su = {CL_AMS_ENTITY_TYPE_ENTITY};
ClAmsEntityT comp = {CL_AMS_ENTITY_TYPE_ENTITY};
ClAmsSUConfigT suConfig =
{
{
CL_AMS_ENTITY_TYPE_ENTITY
}
}
;
ClAmsCompConfigT compConfig = {{CL_AMS_ENTITY_TYPE_ENTITY}};
ClUint64T bitMask = 0;
su.type = CL_AMS_ENTITY_TYPE_SU;
snprintf((ClCharT*)su.name.value, sizeof(su.name.value),
"%s_%s_SU%d", prefix, (const ClCharT*)nodeList[i-suBuffer.count].name.value, i);
su.name.length = strlen((const ClCharT*)su.name.value)+1;
clLogNotice("AMS", "MIGRATE", "Creating SU [%s]", su.name.value);
rc = clAmsMgmtCCBEntityCreate(ccbHandle, &su);
if(rc != CL_OK)
{
clLogError("AMS", "MIGRATE", "SU create returned [%#x]", rc);
goto out_free;
}
memcpy(&sus[i-suBuffer.count], &su, sizeof(su));
/*
* Assign this SU under the parent node and SG
*/
rc = clAmsMgmtCCBSetNodeSUList(ccbHandle, &nodeList[i-suBuffer.count], &su);
if(rc != CL_OK)
{
clLogError("AMS", "MIGRATE", "Node su list set returned [%#x]", rc);
goto out_free;
}
/*
* Give the parent SG. for this SU
*/
rc = clAmsMgmtCCBSetSGSUList(ccbHandle, sgName, &su);
if(rc != CL_OK)
{
clLogError("AMS", "MIGRATE", "Set SG su list returned [%#x]", rc);
goto out_free;
}
bitMask = SU_CONFIG_NUM_COMPONENTS;
memcpy(&suConfig.entity, &su, sizeof(suConfig.entity));
suConfig.numComponents = 1;
rc = clAmsMgmtCCBEntitySetConfig(ccbHandle, &suConfig.entity, bitMask);
if(rc != CL_OK)
{
clLogError("AMS", "MIGRATE", "SU set config returned [%#x]", rc);
goto out_free;
}
comp.type = CL_AMS_ENTITY_TYPE_COMP;
snprintf((ClCharT*) comp.name.value, sizeof(comp.name.value), "%s_Comp%d", su.name.value, i - suBuffer.count);
comp.name.length = strlen((const ClCharT*) comp.name.value) + 1;
clLogNotice("AMS", "MIGRATE", "Creating component [%s]",
comp.name.value);
rc = clAmsMgmtCCBEntityCreate(ccbHandle, &comp);
if(rc != CL_OK)
{
clLogError("AMS", "MIGRATE", "Comp create returned [%#x]", rc);
goto out_free;
}
memcpy(&comps[i-suBuffer.count], &comp, sizeof(comp));
rc = clAmsMgmtCCBSetSUCompList(ccbHandle, &su,
&comp);
if(rc != CL_OK)
{
clLogError("AMS", "MIGRATE", "AMS set su comp list returned [%#x]", rc);
goto out_free;
}
if(pSURefComp)
{
/*
* At this stage, we have created the hierarchy.
* Set the comp property to the base component type and
* add the num supported CSI types to be part of every component
* added to the SU.
*/
bitMask = CL_AMS_CONFIG_ATTR_ALL;
memcpy(&compConfig, pSURefComp, sizeof(compConfig));
memcpy(&compConfig.entity, &comp, sizeof(compConfig.entity));
compConfig.numSupportedCSITypes = numSupportedCSITypes;
compConfig.pSupportedCSITypes = pNumSupportedCSITypes;
memcpy(&compConfig.parentSU.entity, &su, sizeof(compConfig.parentSU.entity));
/*
* Distribute the standbys based on the active/standby ratio.
*/
compConfig.numMaxStandbyCSIs = numActiveSUs;
if(numStandbySUs > 1 )
compConfig.numMaxStandbyCSIs = (numActiveSUs+1)&~1;
compConfig.numMaxStandbyCSIs = CL_MAX(1, compConfig.numMaxStandbyCSIs/
(numStandbySUs?numStandbySUs:1));
rc = clAmsMgmtCCBEntitySetConfig(ccbHandle, &compConfig.entity,
bitMask);
if(rc != CL_OK)
{
clLogError("AMS", "MIGRATE", "AMS set config returned [%#x]", rc);
goto out_free;
}
}
}
}
/*
* At this stage, we are all set to commit. after updating SG config.
*/
{
ClUint64T bitMask = 0;
bitMask |= SG_CONFIG_REDUNDANCY_MODEL;
sgConfig.redundancyModel = model;
sgConfig.numPrefActiveSUs = numActiveSUs;
bitMask |= SG_CONFIG_NUM_PREF_ACTIVE_SUS;
sgConfig.numPrefStandbySUs = numStandbySUs;
bitMask |= SG_CONFIG_NUM_PREF_STANDBY_SUS;
if(sgConfig.numPrefInserviceSUs < numActiveSUs + numStandbySUs)
{
sgConfig.numPrefInserviceSUs = numActiveSUs + numStandbySUs;
bitMask |= SG_CONFIG_NUM_PREF_INSERVICE_SUS;
}
sgConfig.numPrefAssignedSUs = numActiveSUs + numStandbySUs;
bitMask |= SG_CONFIG_NUM_PREF_ASSIGNED_SUS;
/*
* Active standby ratio.
*/
sgConfig.maxStandbySIsPerSU = numActiveSUs;
if(numStandbySUs > 1 )
sgConfig.maxStandbySIsPerSU = (numActiveSUs+1)&~1;
sgConfig.maxStandbySIsPerSU = CL_MAX(1,sgConfig.maxStandbySIsPerSU/
(numStandbySUs?numStandbySUs:1));
bitMask |= SG_CONFIG_MAX_STANDBY_SIS_PER_SU;
rc = clAmsMgmtCCBEntitySetConfig(ccbHandle, &sgConfig.entity, bitMask);
if(rc != CL_OK)
{
clLogError("AMS", "MIGRATE", "AMS sg set config returned [%#x]", rc);
goto out_free;
}
}
rc = clAmsMgmtCCBCommit(ccbHandle);
if(rc != CL_OK)
{
clLogError("AMS", "MIGRATE", "AMS database commit returned [%#x]", rc);
}
/*
* Okay, the commit is successful. Now unlock all added entities
* except SU so that other attributes could be updated before unlocking
* Do that in a separate thread as there could be pending invocations.
*/
unlockList = (ClAmsMgmtMigrateListT*) clHeapCalloc(1, sizeof(*unlockList));
CL_ASSERT(unlockList != NULL);
unlockList->si.count = extraSIs;
unlockList->node.count = extraNodes;
unlockList->su.count = extraSUs;
unlockList->si.entity = (ClAmsEntityT*) clHeapCalloc(extraSIs, sizeof(*sis));
unlockList->node.entity = (ClAmsEntityT*) clHeapCalloc(extraNodes, sizeof(*nodes));
unlockList->su.entity = (ClAmsEntityT*) clHeapCalloc(extraSUs, sizeof(*sus));
CL_ASSERT(unlockList->si.entity && unlockList->node.entity && unlockList->su.entity);
memcpy(unlockList->si.entity, sis, sizeof(*sis)*extraSIs);
memcpy(unlockList->node.entity, nodes, sizeof(*nodes)*extraNodes);
memcpy(unlockList->su.entity, sus, sizeof(*sus) * extraSUs);
clOsalTaskCreateDetached("MIGRATE-UNLOCK-THREAD", CL_OSAL_SCHED_OTHER, 0, 0,
clAmsMgmtMigrateListUnlock, (void*)unlockList);
/*
* Return the newly created info. in the migrated list.
*/
if(migrateList)
{
if(extraSIs)
{
migrateList->si.count = extraSIs;
migrateList->si.entity = sis;
migrateList->csi.count = extraSIs;
migrateList->csi.entity = csis;
sis = csis = NULL;
}
if(extraNodes)
{
migrateList->node.count = extraNodes;
migrateList->node.entity = nodes;
nodes = NULL;
}
if(extraSUs)
{
migrateList->su.count = extraSUs;
migrateList->su.entity = sus;
migrateList->comp.count = extraSUs;
migrateList->comp.entity = comps;
sus = comps = NULL;
}
}
out_free:
clAmsMgmtCCBFinalize(ccbHandle);
if(siBuffer.entity) clHeapFree(siBuffer.entity);
if(nodeBuffer.entity) clHeapFree(nodeBuffer.entity);
if(suBuffer.entity) clHeapFree(suBuffer.entity);
if(nodeList) clHeapFree(nodeList);
if(nodes) clHeapFree(nodes);
if(sus) clHeapFree(sus);
if(comps) clHeapFree(comps);
if(sis) clHeapFree(sis);
if(csis) clHeapFree(csis);
if(pSGRefSI) clHeapFree(pSGRefSI);
if(pSIRefCSI) clHeapFree(pSIRefCSI);
if(pSURefComp) clHeapFree(pSURefComp);
if(pNumSupportedCSITypes) clHeapFree(pNumSupportedCSITypes);
out:
return rc;
}
static PyObject* GetWorkOnServiceGroup(PyObject *self, PyObject *args)
{
char buf[32*1024];
const int bufLen = sizeof(buf);
int curLen = 0;
ClRcT rc;
ClAmsEntityBufferT siList,csiList;
const char* arg0=NULL;
unsigned int siit;
unsigned int csiit;
unsigned int nvpit;
ClAmsMgmtHandleT hdl = amsHandle;
if (!hdl)
{
PyErr_SetString(PyExc_SystemError,"AMF Handle not initialized");
return NULL;
}
if (!PyArg_ParseTuple(args, "s", &arg0))
return NULL;
DbgLog("GetWorkOnNode arg is: %s",arg0);
ClAmsEntityT svcgrp;
svcgrp.type = CL_AMS_ENTITY_TYPE_SG;
clNameSet(&svcgrp.name, arg0);
svcgrp.name.length+=1;
curLen += snprintf(buf+curLen, bufLen-curLen, "{");
siList.entity = NULL;
rc = clAmsMgmtGetSGSIList(hdl, &svcgrp, &siList);
if (CL_GET_ERROR_CODE(rc) == CL_ERR_NOT_EXIST)
{
sprintf(buf,"Service Group %s does not exist",arg0);
PyErr_SetString(PyExc_KeyError,buf);
return NULL;
}
else if (rc != CL_OK)
{
sprintf(buf,"clAmsMgmtGetSGSIList error 0x%x",rc);
PyObject* errData = Py_BuildValue("is",rc,buf);
PyErr_SetObject(PyExc_SystemError,errData);
//PyErr_SetString(PyExc_SystemError,buf);
return NULL;
}
for (siit = 0; siit < siList.count; siit++)
{
ClAmsEntityT* siEnt = &siList.entity[siit];
csiList.entity = NULL;
rc = clAmsMgmtGetSICSIList(hdl, siEnt, &csiList);
DbgLog("4: %s", buf);
curLen += snprintf(buf+curLen, bufLen-curLen, "%s'%.*s':{",(siit==0) ? "":",", siEnt->name.length,siEnt->name.value);
//curLen += snprintf(buf+curLen, bufLen-curLen, "'csiHaState':'%s'", STRING_HA_STATE(si->haState));
if (rc == CL_OK) for (csiit = 0; csiit < csiList.count; csiit++)
{
ClAmsCSINVPBufferT nvpList;
nvpList.nvp = NULL;
rc = clAmsMgmtGetCSINVPList(hdl, &csiList.entity[csiit],&nvpList);
DbgLog("5: %s", buf);
if (rc == CL_OK) for (nvpit = 0; nvpit < nvpList.count; nvpit++)
{
ClAmsCSINameValuePairT* nvp = &nvpList.nvp[nvpit];
curLen += snprintf(buf+curLen, bufLen-curLen, "%s '%.*s':'%.*s'",((csiit==0)&&(nvpit==0)) ? "":",",nvp->paramName.length,nvp->paramName.value,nvp->paramValue.length,nvp->paramValue.value);
DbgLog("6: %s", buf);
}
//curLen += snprintf(buf+curLen, bufLen-curLen, "}");
if (nvpList.nvp) clHeapFree(nvpList.nvp);
}
curLen += snprintf(buf+curLen, bufLen-curLen, "}");
if (csiList.entity) clHeapFree(csiList.entity);
}
curLen += snprintf(buf+curLen, bufLen-curLen, "}");
if (siList.entity) clHeapFree(siList.entity);
clAppLog(CL_LOG_HANDLE_APP, CL_LOG_SEV_INFO, 10, CL_LOG_AREA_UNSPECIFIED, CL_LOG_CONTEXT_UNSPECIFIED,
"AmfDump: %s", buf);
PyObject* ret = PyRun_String(buf,Py_eval_input,emptyDict,emptyDict);
return ret;
}
