(file) Return to CMPIProviderManager.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / ProviderManager2 / CMPI

Diff for /pegasus/src/Pegasus/ProviderManager2/CMPI/CMPIProviderManager.cpp between version 1.114 and 1.115

version 1.114, 2007/08/21 20:10:22 version 1.115, 2007/09/02 16:41:52
Line 66 
Line 66 
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
 int _cmpi_trace=0;  
   
 //Function to throw exception if provider has not been correctly created. //Function to throw exception if provider has not been correctly created.
 void _throw_MINotInitializedException() void _throw_MINotInitializedException()
 { {
     MessageLoaderParms parms(     MessageLoaderParms parms(
         "ProviderManager.CMPI.CMPIProviderManager.PROVIDER_LOAD_FAILURE",         "ProviderManager.CMPI.CMPIProviderManager.PROVIDER_LOAD_FAILURE",
         "ProviderLoadFailure: Cannot find _Create<mi-type>MI symbol.");         "ProviderLoadFailure: Cannot find _Create<mi-type>MI symbol.");
   
     throw CIMException(CIM_ERR_FAILED,MessageLoader::getMessage(parms));     throw CIMException(CIM_ERR_FAILED,MessageLoader::getMessage(parms));
 } }
  
  
 #define DDD(x) if (_cmpi_trace) x;  
   
 ReadWriteSem    CMPIProviderManager::rwSemProvTab; ReadWriteSem    CMPIProviderManager::rwSemProvTab;
 ReadWriteSem    CMPIProviderManager::rwSemSelxTab; ReadWriteSem    CMPIProviderManager::rwSemSelxTab;
 CMPIProviderManager::IndProvTab    CMPIProviderManager::provTab; CMPIProviderManager::IndProvTab    CMPIProviderManager::provTab;
Line 93 
Line 88 
 public: public:
     CMPIPropertyList(CIMPropertyList &propertyList) : props(0), pCount(0)     CMPIPropertyList(CIMPropertyList &propertyList) : props(0), pCount(0)
     {     {
           PEG_METHOD_ENTER(
               TRC_PROVIDERMANAGER,
               "CMPIPropertyList::CMPIPropertyList()");
         if (!propertyList.isNull())         if (!propertyList.isNull())
         {         {
             Array<CIMName> p=propertyList.getPropertyNameArray();             Array<CIMName> p=propertyList.getPropertyNameArray();
Line 105 
Line 103 
             props[pCount]=NULL;             props[pCount]=NULL;
         }         }
         else props=NULL;         else props=NULL;
           PEG_METHOD_EXIT();
     }     }
     ~CMPIPropertyList()     ~CMPIPropertyList()
     {     {
           PEG_METHOD_ENTER(
               TRC_PROVIDERMANAGER,
               "CMPIPropertyList::~CMPIPropertyList()");
         if (props)         if (props)
         {         {
             for (int i=0; i<pCount; i++)             for (int i=0; i<pCount; i++)
                 free(props[i]);                 free(props[i]);
             delete [] props;             delete [] props;
         }         }
           PEG_METHOD_EXIT();
     }     }
     char  **getList()     char  **getList()
     {     {
Line 123 
Line 126 
  
 CMPIProviderManager::CMPIProviderManager(Mode m) CMPIProviderManager::CMPIProviderManager(Mode m)
 { {
       PEG_METHOD_ENTER(
           TRC_PROVIDERMANAGER,
           "CMPIProviderManager::CMPIProviderManager()");
   
     mode=m;     mode=m;
 #ifdef PEGASUS_DEBUG  
     if (getenv("PEGASUS_CMPI_TRACE")) _cmpi_trace=1;  
     else _cmpi_trace=0;  
 #endif  
     _subscriptionInitComplete = false;     _subscriptionInitComplete = false;
     DDD(cerr << "-- CMPI Provider Manager activated" << endl);      PEG_TRACE_CSTRING (
           TRC_PROVIDERMANAGER,
           Tracer::LEVEL2,
           "-- CMPI Provider Manager activated");
       PEG_METHOD_EXIT();
 } }
  
 CMPIProviderManager::~CMPIProviderManager() CMPIProviderManager::~CMPIProviderManager()
 { {
       PEG_METHOD_ENTER(
           TRC_PROVIDERMANAGER,
           "CMPIProviderManager::~CMPIProviderManager()");
     /* Clean up the hash-tables */     /* Clean up the hash-tables */
     indProvRecord *prec=NULL;     indProvRecord *prec=NULL;
     {     {
Line 168 
Line 178 
             selx=NULL;             selx=NULL;
         }         }
     }     }
       PEG_METHOD_EXIT();
 } }
  
 Message * CMPIProviderManager::processMessage(Message * request) Message * CMPIProviderManager::processMessage(Message * request)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,      PEG_METHOD_ENTER(
           TRC_PROVIDERMANAGER,
         "CMPIProviderManager::processMessage()");         "CMPIProviderManager::processMessage()");
  
     Message * response = 0;     Message * response = 0;
Line 341 
Line 353 
 Message * CMPIProviderManager::handleGetInstanceRequest( Message * CMPIProviderManager::handleGetInstanceRequest(
     const Message * message)     const Message * message)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,      PEG_METHOD_ENTER(
         "CMPIProviderManager::handleGetInstanceRequest");          TRC_PROVIDERMANAGER,
           "CMPIProviderManager::handleGetInstanceRequest()");
  
     HandlerIntro(GetInstance,message,request,response,handler);     HandlerIntro(GetInstance,message,request,response,handler);
  
Line 423 
Line 436 
         }         }
 #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,          PEG_TRACE_STRING(
               TRC_PROVIDERMANAGER,
               Tracer::LEVEL4,
             "Calling provider.getInstance: " + pr.getName());             "Calling provider.getInstance: " + pr.getName());
  
         DDD(cerr<<"--- CMPIProviderManager::getInstance"<<endl);  
   
         CMPIStatus rc={CMPI_RC_OK,NULL};         CMPIStatus rc={CMPI_RC_OK,NULL};
         CMPI_ContextOnStack eCtx(context);         CMPI_ContextOnStack eCtx(context);
         CMPI_ObjectPathOnStack eRef(objectPath);         CMPI_ObjectPathOnStack eRef(objectPath);
Line 535 
Line 548 
 Message * CMPIProviderManager::handleEnumerateInstancesRequest( Message * CMPIProviderManager::handleEnumerateInstancesRequest(
     const Message * message)     const Message * message)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,      PEG_METHOD_ENTER(
         "CMPIProviderManager::handleEnumerateInstanceRequest");          TRC_PROVIDERMANAGER,
           "CMPIProviderManager::handleEnumerateInstanceRequest()");
  
     HandlerIntro(EnumerateInstances,message,request,response,handler);     HandlerIntro(EnumerateInstances,message,request,response,handler);
     try     try
Line 618 
Line 632 
         }         }
 #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,          PEG_TRACE_STRING(
               TRC_PROVIDERMANAGER,
               Tracer::LEVEL4,
             "Calling provider.enumerateInstances: " + pr.getName());             "Calling provider.enumerateInstances: " + pr.getName());
  
         DDD(cerr<<"--- CMPIProviderManager::enumerateInstances"<<endl);  
   
         CMPIStatus rc={CMPI_RC_OK,NULL};         CMPIStatus rc={CMPI_RC_OK,NULL};
         CMPI_ContextOnStack eCtx(context);         CMPI_ContextOnStack eCtx(context);
         CMPI_ObjectPathOnStack eRef(objectPath);         CMPI_ObjectPathOnStack eRef(objectPath);
Line 734 
Line 748 
 Message * CMPIProviderManager::handleEnumerateInstanceNamesRequest( Message * CMPIProviderManager::handleEnumerateInstanceNamesRequest(
     const Message * message)     const Message * message)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,      PEG_METHOD_ENTER(
         "CMPIProviderManager::handleEnumerateInstanceNamesRequest");          TRC_PROVIDERMANAGER,
           "CMPIProviderManager::handleEnumerateInstanceNamesRequest()");
  
     HandlerIntro(EnumerateInstanceNames,message,request,response,handler);     HandlerIntro(EnumerateInstanceNames,message,request,response,handler);
     try     try
Line 783 
Line 798 
             request->operationContext.get(ContentLanguageListContainer::NAME));             request->operationContext.get(ContentLanguageListContainer::NAME));
         CMPIProvider & pr=ph.GetProvider();         CMPIProvider & pr=ph.GetProvider();
  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,          PEG_TRACE_STRING(
               TRC_PROVIDERMANAGER,
               Tracer::LEVEL4,
             "Calling provider.enumerateInstanceNames: " + pr.getName());             "Calling provider.enumerateInstanceNames: " + pr.getName());
  
         DDD(cerr<<"--- CMPIProviderManager::enumerateInstanceNames"<<endl);  
   
         CMPIStatus rc={CMPI_RC_OK,NULL};         CMPIStatus rc={CMPI_RC_OK,NULL};
         CMPI_ContextOnStack eCtx(context);         CMPI_ContextOnStack eCtx(context);
         CMPI_ObjectPathOnStack eRef(objectPath);         CMPI_ObjectPathOnStack eRef(objectPath);
Line 890 
Line 905 
 Message * CMPIProviderManager::handleCreateInstanceRequest( Message * CMPIProviderManager::handleCreateInstanceRequest(
     const Message * message)     const Message * message)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,      PEG_METHOD_ENTER(
         "CMPIProviderManager::handleCreateInstanceRequest");          TRC_PROVIDERMANAGER,
           "CMPIProviderManager::handleCreateInstanceRequest()");
  
     HandlerIntro(CreateInstance,message,request,response,handler);     HandlerIntro(CreateInstance,message,request,response,handler);
     try     try
Line 942 
Line 958 
         // forward request         // forward request
         CMPIProvider & pr=ph.GetProvider();         CMPIProvider & pr=ph.GetProvider();
  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,          PEG_TRACE_STRING(
               TRC_PROVIDERMANAGER,
               Tracer::LEVEL4,
             "Calling provider.createInstance: " +             "Calling provider.createInstance: " +
             ph.GetProvider().getName());             ph.GetProvider().getName());
  
         DDD(cerr<<"--- CMPIProviderManager::createInstances"<<endl);  
         CMPIStatus rc={CMPI_RC_OK,NULL};         CMPIStatus rc={CMPI_RC_OK,NULL};
         CMPI_ContextOnStack eCtx(context);         CMPI_ContextOnStack eCtx(context);
         CMPI_ObjectPathOnStack eRef(objectPath);         CMPI_ObjectPathOnStack eRef(objectPath);
Line 1049 
Line 1066 
 Message * CMPIProviderManager::handleModifyInstanceRequest( Message * CMPIProviderManager::handleModifyInstanceRequest(
     const Message * message)     const Message * message)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,      PEG_METHOD_ENTER(
         "CMPIProviderManager::handleModifyInstanceRequest");          TRC_PROVIDERMANAGER,
           "CMPIProviderManager::handleModifyInstanceRequest()");
  
     HandlerIntro(ModifyInstance,message,request,response,handler);     HandlerIntro(ModifyInstance,message,request,response,handler);
     try     try
Line 1100 
Line 1118 
         // forward request         // forward request
         CMPIProvider & pr=ph.GetProvider();         CMPIProvider & pr=ph.GetProvider();
  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,          PEG_TRACE_STRING(
               TRC_PROVIDERMANAGER,
               Tracer::LEVEL4,
             "Calling provider.modifyInstance: " + pr.getName());             "Calling provider.modifyInstance: " + pr.getName());
  
         DDD(cerr<<"--- CMPIProviderManager::modifyInstance"<<endl);  
   
         CMPIStatus rc={CMPI_RC_OK,NULL};         CMPIStatus rc={CMPI_RC_OK,NULL};
         CMPI_ContextOnStack eCtx(context);         CMPI_ContextOnStack eCtx(context);
         CMPI_ObjectPathOnStack eRef(objectPath);         CMPI_ObjectPathOnStack eRef(objectPath);
Line 1211 
Line 1229 
 Message * CMPIProviderManager::handleDeleteInstanceRequest( Message * CMPIProviderManager::handleDeleteInstanceRequest(
     const Message * message)     const Message * message)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,      PEG_METHOD_ENTER(
         "CMPIProviderManager::handleDeleteInstanceRequest");          TRC_PROVIDERMANAGER,
           "CMPIProviderManager::handleDeleteInstanceRequest()");
  
     HandlerIntro(DeleteInstance,message,request,response,handler);     HandlerIntro(DeleteInstance,message,request,response,handler);
     try     try
Line 1262 
Line 1281 
         // forward request         // forward request
         CMPIProvider & pr=ph.GetProvider();         CMPIProvider & pr=ph.GetProvider();
  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,          PEG_TRACE_STRING(
               TRC_PROVIDERMANAGER,
               Tracer::LEVEL4,
             "Calling provider.deleteInstance: " + pr.getName());             "Calling provider.deleteInstance: " + pr.getName());
  
         CMPIStatus rc={CMPI_RC_OK,NULL};         CMPIStatus rc={CMPI_RC_OK,NULL};
Line 1365 
Line 1386 
  
 Message * CMPIProviderManager::handleExecQueryRequest(const Message * message) Message * CMPIProviderManager::handleExecQueryRequest(const Message * message)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,      PEG_METHOD_ENTER(
         "CMPIProviderManager::handleExecQueryRequest");          TRC_PROVIDERMANAGER,
           "CMPIProviderManager::handleExecQueryRequest()");
  
     HandlerIntro(ExecQuery,message,request,response,handler);     HandlerIntro(ExecQuery,message,request,response,handler);
  
Line 1418 
Line 1440 
         // forward request         // forward request
         CMPIProvider & pr=ph.GetProvider();         CMPIProvider & pr=ph.GetProvider();
  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,          PEG_TRACE_STRING(
               TRC_PROVIDERMANAGER,
               Tracer::LEVEL4,
             "Calling provider.execQuery: " + pr.getName());             "Calling provider.execQuery: " + pr.getName());
  
         DDD(cerr<<"--- CMPIProviderManager::execQuery"<<endl);  
   
         const char **props=NULL;         const char **props=NULL;
  
         CMPIStatus rc={CMPI_RC_OK,NULL};         CMPIStatus rc={CMPI_RC_OK,NULL};
Line 1535 
Line 1557 
  
 Message * CMPIProviderManager::handleAssociatorsRequest(const Message * message) Message * CMPIProviderManager::handleAssociatorsRequest(const Message * message)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,      PEG_METHOD_ENTER(
         "CMPIProviderManager::handleAssociatorsRequest");          TRC_PROVIDERMANAGER,
           "CMPIProviderManager::handleAssociatorsRequest()");
  
     HandlerIntro(Associators,message,request,response,handler);     HandlerIntro(Associators,message,request,response,handler);
     try     try
Line 1624 
Line 1647 
         }         }
 #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,          PEG_TRACE_STRING(
               TRC_PROVIDERMANAGER,
               Tracer::LEVEL4,
             "Calling provider.associators: " + pr.getName());             "Calling provider.associators: " + pr.getName());
  
         DDD(cerr<<"--- CMPIProviderManager::associators"<<" role: >"          PEG_TRACE_STRING(
             <<request->role<<"< aCls "<<request->assocClass<<endl);              TRC_PROVIDERMANAGER,
               Tracer::LEVEL4,
               String("--- CMPIProviderManager::associators < role: >" ) +
               request->role +
               request->assocClass.getString());
  
         CMPIStatus rc={CMPI_RC_OK,NULL};         CMPIStatus rc={CMPI_RC_OK,NULL};
         CMPI_ContextOnStack eCtx(context);         CMPI_ContextOnStack eCtx(context);
Line 1743 
Line 1772 
 Message * CMPIProviderManager::handleAssociatorNamesRequest( Message * CMPIProviderManager::handleAssociatorNamesRequest(
     const Message * message)     const Message * message)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,      PEG_METHOD_ENTER(
         "CMPIProviderManager::handleAssociatorNamesRequest");          TRC_PROVIDERMANAGER,
           "CMPIProviderManager::handleAssociatorNamesRequest()");
  
     HandlerIntro(AssociatorNames,message,request,response,handler);     HandlerIntro(AssociatorNames,message,request,response,handler);
     try     try
Line 1801 
Line 1831 
         // forward request         // forward request
         CMPIProvider & pr=ph.GetProvider();         CMPIProvider & pr=ph.GetProvider();
  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,          PEG_TRACE_STRING(
               TRC_PROVIDERMANAGER,
                Tracer::LEVEL4,
             "Calling provider.associatorNames: " + pr.getName());             "Calling provider.associatorNames: " + pr.getName());
  
         DDD(cerr<<"--- CMPIProviderManager::associatorNames"<<" role: >"          PEG_TRACE_STRING(
             <<request->role<<"< aCls "<<request->assocClass<<endl);              TRC_PROVIDERMANAGER,
               Tracer::LEVEL4,
               String("--- CMPIProviderManager::associatorNames --  role: ") +
               request->role + "< aCls " + request->assocClass.getString());
  
         CMPIStatus rc={CMPI_RC_OK,NULL};         CMPIStatus rc={CMPI_RC_OK,NULL};
         CMPI_ContextOnStack eCtx(context);         CMPI_ContextOnStack eCtx(context);
Line 1912 
Line 1947 
  
 Message * CMPIProviderManager::handleReferencesRequest(const Message * message) Message * CMPIProviderManager::handleReferencesRequest(const Message * message)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,      PEG_METHOD_ENTER(
         "CMPIProviderManager::handleReferencesRequest");          TRC_PROVIDERMANAGER,
           "CMPIProviderManager::handleReferencesRequest()");
  
     HandlerIntro(References,message,request,response,handler);     HandlerIntro(References,message,request,response,handler);
     try     try
Line 1999 
Line 2035 
         }         }
 #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,          PEG_TRACE_STRING(
               TRC_PROVIDERMANAGER,
               Tracer::LEVEL4,
             "Calling provider.references: " + pr.getName());             "Calling provider.references: " + pr.getName());
  
         DDD(cerr<<"--- CMPIProviderManager::references"<<" role: >"          PEG_TRACE_STRING(
             <<request->role<<"< aCls "<<request->resultClass<<endl);              TRC_PROVIDERMANAGER, Tracer::LEVEL4,
               String("--- CMPIProviderManager::references -- role:") +
               request->role + "< aCls " + request->resultClass.getString());
  
         CMPIStatus rc={CMPI_RC_OK,NULL};         CMPIStatus rc={CMPI_RC_OK,NULL};
         CMPI_ContextOnStack eCtx(context);         CMPI_ContextOnStack eCtx(context);
Line 2113 
Line 2153 
 Message * CMPIProviderManager::handleReferenceNamesRequest( Message * CMPIProviderManager::handleReferenceNamesRequest(
     const Message * message)     const Message * message)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,      PEG_METHOD_ENTER(
         "CMPIProviderManager::handleReferenceNamesRequest");          TRC_PROVIDERMANAGER,
           "CMPIProviderManager::handleReferenceNamesRequest()");
  
     HandlerIntro(ReferenceNames,message,request,response,handler);     HandlerIntro(ReferenceNames,message,request,response,handler);
     try     try
Line 2169 
Line 2210 
             request->operationContext.get(ContentLanguageListContainer::NAME));             request->operationContext.get(ContentLanguageListContainer::NAME));
         CMPIProvider & pr=ph.GetProvider();         CMPIProvider & pr=ph.GetProvider();
  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,          PEG_TRACE_STRING(
               TRC_PROVIDERMANAGER,
               Tracer::LEVEL4,
             "Calling provider.referenceNames: " + pr.getName());             "Calling provider.referenceNames: " + pr.getName());
  
         DDD(cerr<<"--- CMPIProviderManager::referenceNames"<<" role: >"          PEG_TRACE_STRING(
             <<request->role<<"< aCls "<<request->resultClass<<endl);              TRC_PROVIDERMANAGER,
               Tracer::LEVEL4,
               String("--- CMPIProviderManager::referenceNames -- role: ") +
               request->role + "< aCls " + request->resultClass.getString());
  
         CMPIStatus rc={CMPI_RC_OK,NULL};         CMPIStatus rc={CMPI_RC_OK,NULL};
         CMPI_ContextOnStack eCtx(context);         CMPI_ContextOnStack eCtx(context);
Line 2279 
Line 2325 
 Message * CMPIProviderManager::handleInvokeMethodRequest( Message * CMPIProviderManager::handleInvokeMethodRequest(
     const Message * message)     const Message * message)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,      PEG_METHOD_ENTER(
         "CMPIProviderManager::handleInvokeMethodRequest");          TRC_PROVIDERMANAGER,
           "CMPIProviderManager::handleInvokeMethodRequest()");
  
     HandlerIntro(InvokeMethod,message,request,response,handler);     HandlerIntro(InvokeMethod,message,request,response,handler);
     try     try
Line 2368 
Line 2415 
         }         }
 #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,          PEG_TRACE_STRING(
               TRC_PROVIDERMANAGER,
               Tracer::LEVEL4,
             "Calling provider.invokeMethod: " + pr.getName());             "Calling provider.invokeMethod: " + pr.getName());
  
         CMPIStatus rc={CMPI_RC_OK,NULL};         CMPIStatus rc={CMPI_RC_OK,NULL};
Line 2564 
Line 2613 
     String& providerName,     String& providerName,
     String& location)     String& location)
 { {
      PEG_METHOD_ENTER(
           TRC_PROVIDERMANAGER,
           "CMPIProviderManager:LocateIndicationProviderNames()");
     Uint32 pos = pInstance.findProperty(CIMName ("Name"));     Uint32 pos = pInstance.findProperty(CIMName ("Name"));
     pInstance.getProperty(pos).getValue().get(providerName);     pInstance.getProperty(pos).getValue().get(providerName);
  
     pos = pmInstance.findProperty(CIMName ("Location"));     pos = pmInstance.findProperty(CIMName ("Location"));
     pmInstance.getProperty(pos).getValue().get(location);     pmInstance.getProperty(pos).getValue().get(location);
       PEG_METHOD_EXIT();
     return 0;     return 0;
 } }
  
 Message * CMPIProviderManager::handleCreateSubscriptionRequest( Message * CMPIProviderManager::handleCreateSubscriptionRequest(
     const Message * message)     const Message * message)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,      PEG_METHOD_ENTER(
         "CMPIProviderManager::handleCreateSubscriptionRequest");          TRC_PROVIDERMANAGER,
           "CMPIProviderManager::handleCreateSubscriptionRequest()");
  
     HandlerIntroInd(CreateSubscription,message,request,response,     HandlerIntroInd(CreateSubscription,message,request,response,
         handler);         handler);
Line 2694 
Line 2748 
  
         CMPI_ThreadContext thr(&pr.broker,&eCtx);         CMPI_ThreadContext thr(&pr.broker,&eCtx);
  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,          PEG_TRACE_STRING(
               TRC_PROVIDERMANAGER,
               Tracer::LEVEL4,
             "Calling provider.createSubscriptionRequest: " + pr.getName());             "Calling provider.createSubscriptionRequest: " + pr.getName());
  
         DDD(cerr<<"--- CMPIProviderManager::createSubscriptionRequest"<<endl);  
   
         for (Uint32 i = 0, n = request->classNames.size(); i < n; i++)         for (Uint32 i = 0, n = request->classNames.size(); i < n; i++)
         {         {
             CIMObjectPath className(             CIMObjectPath className(
Line 2850 
Line 2904 
 Message * CMPIProviderManager::handleDeleteSubscriptionRequest( Message * CMPIProviderManager::handleDeleteSubscriptionRequest(
     const Message * message)     const Message * message)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,      PEG_METHOD_ENTER(
         "CMPIProviderManager::handleDeleteSubscriptionRequest");          TRC_PROVIDERMANAGER,
           "CMPIProviderManager::handleDeleteSubscriptionRequest()");
  
     HandlerIntroInd(DeleteSubscription,message,request,response,     HandlerIntroInd(DeleteSubscription,message,request,response,
         handler);         handler);
Line 2945 
Line 3000 
         CMPI_ContextOnStack eCtx(context);         CMPI_ContextOnStack eCtx(context);
         CMPI_ThreadContext thr(&pr.broker,&eCtx);         CMPI_ThreadContext thr(&pr.broker,&eCtx);
  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,          PEG_TRACE_STRING(
               TRC_PROVIDERMANAGER,
               Tracer::LEVEL4,
             "Calling provider.deleteSubscriptionRequest: " + pr.getName());             "Calling provider.deleteSubscriptionRequest: " + pr.getName());
  
         DDD(cerr<<"--- CMPIProviderManager::deleteSubscriptionRequest"<<endl);  
   
         const IdentityContainer container =         const IdentityContainer container =
             request->operationContext.get(IdentityContainer::NAME);             request->operationContext.get(IdentityContainer::NAME);
         eCtx.ft->addEntry(&eCtx,         eCtx.ft->addEntry(&eCtx,
Line 3073 
Line 3128 
 Message * CMPIProviderManager::handleDisableModuleRequest( Message * CMPIProviderManager::handleDisableModuleRequest(
     const Message * message)     const Message * message)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,      PEG_METHOD_ENTER(
         "CMPIProviderManager::handleDisableModuleRequest");          TRC_PROVIDERMANAGER,
           "CMPIProviderManager::handleDisableModuleRequest()");
  
     CIMDisableModuleRequestMessage * request =     CIMDisableModuleRequestMessage * request =
         dynamic_cast<CIMDisableModuleRequestMessage *>(         dynamic_cast<CIMDisableModuleRequestMessage *>(
Line 3161 
Line 3217 
 Message * CMPIProviderManager::handleEnableModuleRequest( Message * CMPIProviderManager::handleEnableModuleRequest(
     const Message * message)     const Message * message)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,      PEG_METHOD_ENTER(
         "CMPIProviderManager::handleEnableModuleRequest");          TRC_PROVIDERMANAGER,
           "CMPIProviderManager::handleEnableModuleRequest()");
  
     CIMEnableModuleRequestMessage * request =     CIMEnableModuleRequestMessage * request =
         dynamic_cast<CIMEnableModuleRequestMessage *>(         dynamic_cast<CIMEnableModuleRequestMessage *>(
Line 3193 
Line 3250 
 Message * CMPIProviderManager::handleStopAllProvidersRequest( Message * CMPIProviderManager::handleStopAllProvidersRequest(
     const Message * message)     const Message * message)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,      PEG_METHOD_ENTER(
         "CMPIProviderManager::handleStopAllProvidersRequest");          TRC_PROVIDERMANAGER,
           "CMPIProviderManager::handleStopAllProvidersRequest()");
  
     CIMStopAllProvidersRequestMessage * request =     CIMStopAllProvidersRequestMessage * request =
         dynamic_cast<CIMStopAllProvidersRequestMessage *>(         dynamic_cast<CIMStopAllProvidersRequestMessage *>(
Line 3254 
Line 3312 
 Message * CMPIProviderManager::handleSubscriptionInitCompleteRequest( Message * CMPIProviderManager::handleSubscriptionInitCompleteRequest(
     const Message * message)     const Message * message)
 { {
     PEG_METHOD_ENTER (TRC_PROVIDERMANAGER,      PEG_METHOD_ENTER(
         "CMPIProviderManager::handleSubscriptionInitCompleteRequest");          TRC_PROVIDERMANAGER,
           "CMPIProviderManager::handleSubscriptionInitCompleteRequest()");
  
     CIMSubscriptionInitCompleteRequestMessage * request =     CIMSubscriptionInitCompleteRequestMessage * request =
         dynamic_cast <CIMSubscriptionInitCompleteRequestMessage *>         dynamic_cast <CIMSubscriptionInitCompleteRequestMessage *>
Line 3324 
Line 3383 
         }         }
         catch (const CIMException & e)         catch (const CIMException & e)
         {         {
             PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,              PEG_TRACE_STRING(
                   TRC_PROVIDERMANAGER,
                   Tracer::LEVEL2,
                 "CIMException: " + e.getMessage ());                 "CIMException: " + e.getMessage ());
         }         }
         catch (const Exception & e)         catch (const Exception & e)
         {         {
             PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,              PEG_TRACE_STRING(
                   TRC_PROVIDERMANAGER,
                   Tracer::LEVEL2,
                 "Exception: " + e.getMessage ());                 "Exception: " + e.getMessage ());
         }         }
         catch (...)         catch (...)
         {         {
             PEG_TRACE_CSTRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,              PEG_TRACE_CSTRING(
                   TRC_PROVIDERMANAGER,
                   Tracer::LEVEL2,
                 "Unknown error in handleSubscriptionInitCompleteRequest");                 "Unknown error in handleSubscriptionInitCompleteRequest");
         }         }
     }     }
Line 3346 
Line 3411 
 Message * CMPIProviderManager::handleGetPropertyRequest( Message * CMPIProviderManager::handleGetPropertyRequest(
     const Message * message)     const Message * message)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,      PEG_METHOD_ENTER(
         "CMPIProviderManager::handleGetPropertyRequest");          TRC_PROVIDERMANAGER,
           "CMPIProviderManager::handleGetPropertyRequest()");
  
     HandlerIntro(GetProperty,message,request,response,handler);     HandlerIntro(GetProperty,message,request,response,handler);
  
Line 3465 
Line 3531 
         }         }
 #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,          PEG_TRACE_STRING(
               TRC_PROVIDERMANAGER,
               Tracer::LEVEL4,
             "Calling provider.getInstance via getProperty: " + pr.getName());             "Calling provider.getInstance via getProperty: " + pr.getName());
  
         DDD(cerr<<"--- CMPIProviderManager::getInstance via getProperty"  
             <<endl);  
   
         CMPIStatus rc={CMPI_RC_OK,NULL};         CMPIStatus rc={CMPI_RC_OK,NULL};
         CMPI_ContextOnStack eCtx(context);         CMPI_ContextOnStack eCtx(context);
         CMPI_ObjectPathOnStack eRef(objectPath);         CMPI_ObjectPathOnStack eRef(objectPath);
Line 3604 
Line 3669 
 Message * CMPIProviderManager::handleSetPropertyRequest( Message * CMPIProviderManager::handleSetPropertyRequest(
     const Message * message)     const Message * message)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,      PEG_METHOD_ENTER(
         "CMPIProviderManager::handleSetPropertyRequest");          TRC_PROVIDERMANAGER,
           "CMPIProviderManager::handleSetPropertyRequest()");
  
     HandlerIntro(SetProperty,message,request,response,handler);     HandlerIntro(SetProperty,message,request,response,handler);
  
Line 3697 
Line 3763 
         // forward request         // forward request
         CMPIProvider & pr=ph.GetProvider();         CMPIProvider & pr=ph.GetProvider();
  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,          PEG_TRACE_STRING(
               TRC_PROVIDERMANAGER,
               Tracer::LEVEL4,
             "Calling provider.modifyInstance via setProperty: " + pr.getName());             "Calling provider.modifyInstance via setProperty: " + pr.getName());
  
         DDD(cerr<<"--- CMPIProviderManager::modifyInstance via setProperty"  
             <<endl);  
   
         CMPIStatus rc={CMPI_RC_OK,NULL};         CMPIStatus rc={CMPI_RC_OK,NULL};
         CMPI_ContextOnStack eCtx(context);         CMPI_ContextOnStack eCtx(context);
         CMPI_ObjectPathOnStack eRef(objectPath);         CMPI_ObjectPathOnStack eRef(objectPath);
Line 3812 
Line 3877 
 Message * CMPIProviderManager::handleUnsupportedRequest( Message * CMPIProviderManager::handleUnsupportedRequest(
     const Message * message)     const Message * message)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,      PEG_METHOD_ENTER(
         "CMPIProviderManager::handleUnsupportedRequest");          TRC_PROVIDERMANAGER,
           "CMPIProviderManager::handleUnsupportedRequest()");
     CIMRequestMessage* request =     CIMRequestMessage* request =
         dynamic_cast<CIMRequestMessage *>(const_cast<Message *>(message));         dynamic_cast<CIMRequestMessage *>(const_cast<Message *>(message));
     PEGASUS_ASSERT(request != 0 );     PEGASUS_ASSERT(request != 0 );
Line 3835 
Line 3901 
     String moduleName;     String moduleName;
     CIMValue genericValue;     CIMValue genericValue;
  
       PEG_METHOD_ENTER(
           TRC_PROVIDERMANAGER,
           "CMPIProviderManager::_resolveProviderName()");
   
     genericValue = providerId.getModule().getProperty(     genericValue = providerId.getModule().getProperty(
         providerId.getModule().findProperty("Name")).getValue();         providerId.getModule().findProperty("Name")).getValue();
     genericValue.get(moduleName);     genericValue.get(moduleName);
Line 3863 
Line 3933 
     }     }
     ProviderName name(moduleName, providerName, fileName);     ProviderName name(moduleName, providerName, fileName);
     name.setLocation(location);     name.setLocation(location);
       PEG_METHOD_EXIT();
     return name;     return name;
 } }
  
Line 3872 
Line 3943 
     CMPIProvider::OpProviderHolder & ph,     CMPIProvider::OpProviderHolder & ph,
     const char* remoteInfo)     const char* remoteInfo)
 { {
     PEG_METHOD_ENTER (TRC_PROVIDERMANAGER,      PEG_METHOD_ENTER(
         "CMPIProviderManager::_callEnableIndications");          TRC_PROVIDERMANAGER,
           "CMPIProviderManager::_callEnableIndications()");
  
     try     try
     {     {
Line 3928 
Line 4000 
                     (CMPIValue*)(const char*)remoteInfo,CMPI_chars);                     (CMPIValue*)(const char*)remoteInfo,CMPI_chars);
             }             }
  
             PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,              PEG_TRACE_STRING(
                   TRC_PROVIDERMANAGER,
                   Tracer::LEVEL4,
                 "Calling provider.enableIndications: " + pr.getName());                 "Calling provider.enableIndications: " + pr.getName());
  
             DDD(cerr<<"--- provider.enableIndications"<<endl);  
   
             pr.protect();             pr.protect();
  
             // enableIndications() is defined by the CMPI standard as             // enableIndications() is defined by the CMPI standard as
Line 3949 
Line 4021 
         }         }
         else         else
         {         {
             PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,              PEG_TRACE_STRING(
                   TRC_PROVIDERMANAGER,
                   Tracer::LEVEL4,
                 "Not calling provider.enableIndications: " + pr.getName() +                 "Not calling provider.enableIndications: " + pr.getName() +
                 " routine as it is an earlier version that does not support " \                 " routine as it is an earlier version that does not support " \
                 "this function");                 "this function");
   
             DDD(cerr<<"--- provider.enableIndications " \  
                 "cannot be called as the provider uses an earlier version " \  
                 "that does not support this function"<<endl);  
         }         }
     }     }
     catch (const Exception & e)     catch (const Exception & e)
     {     {
         PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,          PEG_TRACE_STRING(
               TRC_PROVIDERMANAGER,
               Tracer::LEVEL2,
             "Exception in _callEnableIndications: " + e.getMessage ());             "Exception in _callEnableIndications: " + e.getMessage ());
  
         Logger::put_l (Logger::ERROR_LOG, System::CIMSERVER, Logger::WARNING,         Logger::put_l (Logger::ERROR_LOG, System::CIMSERVER, Logger::WARNING,
Line 3972 
Line 4044 
     }     }
     catch (...)     catch (...)
     {     {
         PEG_TRACE_CSTRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,          PEG_TRACE_CSTRING(
               TRC_PROVIDERMANAGER,
               Tracer::LEVEL2,
             "Unexpected error in _callEnableIndications");             "Unexpected error in _callEnableIndications");
  
         Logger::put_l (Logger::ERROR_LOG, System::CIMSERVER, Logger::WARNING,         Logger::put_l (Logger::ERROR_LOG, System::CIMSERVER, Logger::WARNING,
Line 3988 
Line 4062 
 void CMPIProviderManager::_callDisableIndications void CMPIProviderManager::_callDisableIndications
     (CMPIProvider::OpProviderHolder & ph, const char *remoteInfo)     (CMPIProvider::OpProviderHolder & ph, const char *remoteInfo)
 { {
     PEG_METHOD_ENTER (TRC_PROVIDERMANAGER,      PEG_METHOD_ENTER(
         "CMPIProviderManager::_callDisableIndications");          TRC_PROVIDERMANAGER,
           "CMPIProviderManager::_callDisableIndications()");
  
     try     try
     {     {
Line 4027 
Line 4102 
             }             }
             CMPI_ThreadContext thr(&pr.broker,&eCtx);             CMPI_ThreadContext thr(&pr.broker,&eCtx);
  
             PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,              PEG_TRACE_STRING(
                   TRC_PROVIDERMANAGER,
                   Tracer::LEVEL4,
                 "Calling provider.disableIndications: " + pr.getName());                 "Calling provider.disableIndications: " + pr.getName());
  
             DDD(cerr<<"--- provider.disableIndications"<<endl);  
   
   
             // disableIndications() is defined by the CMPI standard as             // disableIndications() is defined by the CMPI standard as
             // returning a CMPIStatus return value. Unfortunately, Pegasus             // returning a CMPIStatus return value. Unfortunately, Pegasus
             // originally implemented disableIndications() with a void             // originally implemented disableIndications() with a void
Line 4050 
Line 4124 
         }         }
         else         else
         {         {
             PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,              PEG_TRACE_STRING(
                   TRC_PROVIDERMANAGER,
                   Tracer::LEVEL4,
                 "Not calling provider.disableIndications: "                 "Not calling provider.disableIndications: "
                 + pr.getName() +                 + pr.getName() +
                 " routine as it is an earlier version that does not support" \                 " routine as it is an earlier version that does not support" \
                 " this function");                 " this function");
   
             DDD(cerr<<"--- provider.disableIndications " \  
                 "cannot be called as the provider uses an earlier version " \  
                 "that does not support this function"<<endl);  
         }         }
     }     }
     catch (const Exception & e)     catch (const Exception & e)
     {     {
         PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,          PEG_TRACE_STRING(
               TRC_PROVIDERMANAGER,
               Tracer::LEVEL2,
             "Exception in _callDisableIndications: " + e.getMessage ());             "Exception in _callDisableIndications: " + e.getMessage ());
  
         Logger::put_l (Logger::ERROR_LOG, System::CIMSERVER, Logger::WARNING,         Logger::put_l (Logger::ERROR_LOG, System::CIMSERVER, Logger::WARNING,
Line 4074 
Line 4148 
     }     }
     catch (...)     catch (...)
     {     {
         PEG_TRACE_CSTRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,          PEG_TRACE_CSTRING(
               TRC_PROVIDERMANAGER,
               Tracer::LEVEL2,
             "Unexpected error in _callDisableIndications");             "Unexpected error in _callDisableIndications");
  
         Logger::put_l (Logger::ERROR_LOG, System::CIMSERVER, Logger::WARNING,         Logger::put_l (Logger::ERROR_LOG, System::CIMSERVER, Logger::WARNING,

Legend:
Removed from v.1.114  
changed lines
  Added in v.1.115
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2