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;
}
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 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;
}