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

Diff for /pegasus/src/Pegasus/ProviderManager2/CMPI/CMPILocalProviderManager.cpp between version 1.12 and 1.13

version 1.12, 2004/10/17 20:40:01 version 1.13, 2004/12/23 09:40:49
Line 31 
Line 31 
 //              Mike Day IBM Corporation (mdday@us.ibm.com) //              Mike Day IBM Corporation (mdday@us.ibm.com)
 //              Adrian Schuur, schuur@de.ibm.com //              Adrian Schuur, schuur@de.ibm.com
 //              Dan Gorey, IBM djgorey@us.ibm.com //              Dan Gorey, IBM djgorey@us.ibm.com
   //              Robert Kieninger, IBM (kieningr@de.ibm.com)
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 52 
Line 53 
 #undef IDLE_LIMIT #undef IDLE_LIMIT
 #define IDLE_LIMIT 50 #define IDLE_LIMIT 50
 CMPILocalProviderManager::CMPILocalProviderManager(void) CMPILocalProviderManager::CMPILocalProviderManager(void)
     : _idle_timeout(IDLE_LIMIT)  : _idle_timeout(IDLE_LIMIT) {
 {  
 } }
  
 CMPILocalProviderManager::~CMPILocalProviderManager(void)  CMPILocalProviderManager::~CMPILocalProviderManager(void) {
 {  
     Uint32 ccode;     Uint32 ccode;
  
 //    _provider_ctrl(UNLOAD_ALL_PROVIDERS, this, &ccode); //    _provider_ctrl(UNLOAD_ALL_PROVIDERS, this, &ccode);
  
 } }
  
 Sint32 CMPILocalProviderManager::_provider_ctrl(CTRL code, void *parm, void *ret)  Sint32 CMPILocalProviderManager::_provider_ctrl(CTRL code, void *parm, void *ret) {
 {  
  
     static Uint32 quantum;     static Uint32 quantum;
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "_provider_ctrl");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "_provider_ctrl");
Line 73 
Line 71 
     Sint32 ccode = 0;     Sint32 ccode = 0;
     CTRL_STRINGS *parms = reinterpret_cast<CTRL_STRINGS *>(parm);     CTRL_STRINGS *parms = reinterpret_cast<CTRL_STRINGS *>(parm);
  
     switch(code)     switch (code) {
     {  
  
     case GET_PROVIDER:     case GET_PROVIDER:
         {         {
Line 92 
Line 89 
  
             pr = _lookupProvider(providerName);             pr = _lookupProvider(providerName);
  
             if(pr->getStatus() != CMPIProvider::INITIALIZED)           if (pr->getStatus() != CMPIProvider::INITIALIZED) {
             {  
                 pr->setLocation(location);                 pr->setLocation(location);
                 _initProvider(pr,moduleFileName);                 _initProvider(pr,moduleFileName);
             }             }
  
             if(pr->_status != CMPIProvider::INITIALIZED)           if (pr->_status != CMPIProvider::INITIALIZED) {
             {  
                 PEG_METHOD_EXIT();                 PEG_METHOD_EXIT();
                 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,"provider initialization failed");                 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,"provider initialization failed");
             }             }
Line 121 
Line 116 
                 "_provider_ctrl::UNLOAD_PROVIDER");                 "_provider_ctrl::UNLOAD_PROVIDER");
             CMPIProvider *pr = _lookupProvider(*(parms->providerName));             CMPIProvider *pr = _lookupProvider(*(parms->providerName));
  
                 if((pr->getStatus() == CMPIProvider::INITIALIZED))           if ((pr->getStatus() == CMPIProvider::INITIALIZED)) {
                 {  
  
  
                 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,                 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
Line 143 
Line 137 
             AutoMutex lock(_providerTableMutex);             AutoMutex lock(_providerTableMutex);
  
             if(true == _providers.lookup(*(parms->providerName),             if(true == _providers.lookup(*(parms->providerName),
                 *(reinterpret_cast<CMPIProvider * *>(ret))))                                         *(reinterpret_cast<CMPIProvider * *>(ret)))) {
             {  
                 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,                 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
                     "Found CMPIProvider in cache: " +                     "Found CMPIProvider in cache: " +
                     *(parms->providerName));                     *(parms->providerName));
  
                 (*(reinterpret_cast<CMPIProvider * *>(ret)))->update_idle_timer();                 (*(reinterpret_cast<CMPIProvider * *>(ret)))->update_idle_timer();
             }             }
             else           else {
             {  
  
                 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,                 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
                     "Could not find  CMPIProvider in cache: " +                     "Could not find  CMPIProvider in cache: " +
Line 172 
Line 164 
              AutoMutex lock(_providerTableMutex);              AutoMutex lock(_providerTableMutex);
  
             if(false  == _modules.lookup(*(parms->fileName),             if(false  == _modules.lookup(*(parms->fileName),
                 *(reinterpret_cast<CMPIProviderModule * *>(ret))))                                         *(reinterpret_cast<CMPIProviderModule * *>(ret)))) {
             {  
                 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,                 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
                     "Could not find  CMPIProvider Module in cache: " +                     "Could not find  CMPIProvider Module in cache: " +
                     *(parms->fileName));                     *(parms->fileName));
Line 219 
Line 210 
             Tracer::trace(TRC_PROVIDERMANAGER,Tracer::LEVEL4,             Tracer::trace(TRC_PROVIDERMANAGER,Tracer::LEVEL4,
                           "providers in cache = %d", myself->_providers.size());                           "providers in cache = %d", myself->_providers.size());
             ProviderTable::Iterator i = myself->_providers.start();             ProviderTable::Iterator i = myself->_providers.start();
             try           try {
             {              for (; i != 0; i++) {
                 for(; i != 0; i++)  
                 {  
                     provider = i.value();                     provider = i.value();
                     PEGASUS_ASSERT(provider!=0);                     PEGASUS_ASSERT(provider!=0);
                     if(provider->getStatus()==CMPIProvider::UNINITIALIZED)                 if (provider->getStatus()==CMPIProvider::UNINITIALIZED) {
                     {  
                         continue;                         continue;
                     }                     }
                     else                 else {
                     {  
                         _unloadProvider(provider);                         _unloadProvider(provider);
                     }                     }
                 }                 }
  
             }             }
             catch(...)           catch (...) {
             {  
                 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,                 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
                     "Unexpected Exception in UNLOAD_ALL_PROVIDERS.");                     "Unexpected Exception in UNLOAD_ALL_PROVIDERS.");
             }             }
Line 254 
Line 240 
             CMPILocalProviderManager *myself =             CMPILocalProviderManager *myself =
                 reinterpret_cast<CMPILocalProviderManager *>(parm);                 reinterpret_cast<CMPILocalProviderManager *>(parm);
             CMPIProvider * provider;             CMPIProvider * provider;
            Uint32 numProviders = myself->_providers.size();
   
            if (numProviders) {
               // Rather than removing the provider immediately while
               // iterating through the list we remember all candidates
               // for unload in a simple array.
               CMPIProvider** unloadProviderArray = new CMPIProvider*[numProviders];
               Uint32 upaIndex = 0;
  
             if(myself->_providers.size()) {  
                 try {                 try {
                     struct timeval now;                     struct timeval now;
                     gettimeofday(&now, NULL);                     gettimeofday(&now, NULL);
Line 292 
Line 285 
  
                         if (provider->unload_ok() == true &&                         if (provider->unload_ok() == true &&
                               (now.tv_sec - timeout.tv_sec) > ((Sint32)myself->_idle_timeout)) {                               (now.tv_sec - timeout.tv_sec) > ((Sint32)myself->_idle_timeout)) {
                             AutoMutex pr_lock(provider->_statusMutex);                       // Remember this provider to be unloaded
                             Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,                       unloadProviderArray[upaIndex] = provider;
                                 "ProviderManager::_provider_crtl -  Unload idle provider $0",                       upaIndex++;
                                 provider->getName());  
   
                             PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
                                 "Trying to Terminate CMPIProvider " + provider->getName());  
                             try {  
                                 if (false == provider->tryTerminate()) {  
                                     PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
                                         "CMPIProvider Refused Termination " + provider->getName());  
                                     continue;  
                                 }                                 }
                                 else  {                    //else cout<<"--- NOT unloaded: "+ provider->getName()<<endl;
                                     PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
                                         "CMPIProvider terminated: " +  provider->getName());  
                                }  
                             }  
                             catch(...) {  
                                 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
                                     "Exception terminating " +  
                                     provider->getName());  
                                 continue;  
                             }                             }
                             PEGASUS_ASSERT(provider->_module!=0);  
                             PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
                                 "unloading provider module " + provider->getName());  
                                 provider->_module->unloadModule();  
  
                  // Now finally we unload all providers that we identified as
                  // candidates above.
                  for (Uint32 index=0; index < upaIndex; index++) {
                                 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,                                 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
                                     "Destroying CMPIProvider's CIMOM Handle: " +                                     "Now trying to unload CMPIProvider " + provider->getName());
                                     provider->getName());                    if (provider->unload_ok() == true)
                                 _providers.remove(provider->getName());                    {
                                 delete provider->_cimom_handle;                       _unloadProvider(unloadProviderArray[index]);
                                 provider->reset();  
                                 delete provider;  
                         }                         }
                         //else cout<<"--- NOT unloaded: "+ provider->getName()<<endl;  
                     }                     }
                 }                 }
                 catch(...) {                 catch(...) {
                     PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,                     PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
                         "Unexpected Exception in UNLOAD_IDLE_PROVIDERS.");                         "Unexpected Exception in UNLOAD_IDLE_PROVIDERS.");
                 }                 }
               delete unloadProviderArray;
             } // if there are any providers             } // if there are any providers
             break;             break;
         }         }
Line 350 
Line 322 
  
 CMPIProvider::OpProviderHolder CMPILocalProviderManager::getRemoteProvider( CMPIProvider::OpProviderHolder CMPILocalProviderManager::getRemoteProvider(
     const String & location,     const String & location,
     const String & providerName)                                                                            const String & providerName) {
 {  
     CMPIProvider::OpProviderHolder ph;     CMPIProvider::OpProviderHolder ph;
     CTRL_STRINGS strings;     CTRL_STRINGS strings;
     Sint32 ccode;     Sint32 ccode;
Line 385 
Line 356 
  
 CMPIProvider::OpProviderHolder CMPILocalProviderManager::getProvider( CMPIProvider::OpProviderHolder CMPILocalProviderManager::getProvider(
     const String & fileName,     const String & fileName,
     const String & providerName)                                                                      const String & providerName) {
 {  
     CMPIProvider::OpProviderHolder ph;     CMPIProvider::OpProviderHolder ph;
     CTRL_STRINGS strings;     CTRL_STRINGS strings;
     Sint32 ccode;     Sint32 ccode;
Line 420 
Line 390 
  
 void CMPILocalProviderManager::unloadProvider( void CMPILocalProviderManager::unloadProvider(
     const String & fileName,     const String & fileName,
     const String & providerName)                                               const String & providerName) {
 {  
     CTRL_STRINGS strings;     CTRL_STRINGS strings;
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "ProviderManager::unloadProvider");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "ProviderManager::unloadProvider");
     strings.fileName = &fileName;     strings.fileName = &fileName;
Line 430 
Line 399 
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
 } }
  
 void CMPILocalProviderManager::shutdownAllProviders(void)  void CMPILocalProviderManager::shutdownAllProviders(void) {
 {  
  
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "ProviderManager::shutdownAllProviders");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "ProviderManager::shutdownAllProviders");
     _provider_ctrl(UNLOAD_ALL_PROVIDERS, (void *)this, (void *)0);     _provider_ctrl(UNLOAD_ALL_PROVIDERS, (void *)this, (void *)0);
Line 439 
Line 407 
 } }
  
  
 Boolean CMPILocalProviderManager::hasActiveProviders()  Boolean CMPILocalProviderManager::hasActiveProviders() {
 {  
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
         "ProviderManager::hasActiveProviders");         "ProviderManager::hasActiveProviders");
  
     try     try {
     {  
         AutoMutex lock(_providerTableMutex);         AutoMutex lock(_providerTableMutex);
         Tracer::trace(TRC_PROVIDERMANAGER, Tracer::LEVEL4,         Tracer::trace(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
             "providers in _providers table = %d", _providers.size());             "providers in _providers table = %d", _providers.size());
  
         // Iterate through the _providers table looking for an active provider         // Iterate through the _providers table looking for an active provider
         for (ProviderTable::Iterator i = _providers.start(); i != 0; i++)        for (ProviderTable::Iterator i = _providers.start(); i != 0; i++) {
         {           if (i.value()->getStatus() == CMPIProvider::INITIALIZED) {
             if (i.value()->getStatus() == CMPIProvider::INITIALIZED)  
             {  
                 PEG_METHOD_EXIT();                 PEG_METHOD_EXIT();
                 return true;                 return true;
             }             }
         }         }
     }     }
     catch (...)     catch (...) {
     {  
         // Unexpected exception; do not assume that no providers are loaded         // Unexpected exception; do not assume that no providers are loaded
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
             "Unexpected Exception in hasActiveProviders.");             "Unexpected Exception in hasActiveProviders.");
Line 474 
Line 437 
     return false;     return false;
 } }
  
 void CMPILocalProviderManager::unloadIdleProviders(void)  void CMPILocalProviderManager::unloadIdleProviders(void) {
 {  
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
         "ProviderManager::unloadIdleProviders");         "ProviderManager::unloadIdleProviders");
  
     static struct timeval first = {0,0}, now, last = {0,0};     static struct timeval first = {0,0}, now, last = {0,0};
  
     if(first.tv_sec == 0)     if (first.tv_sec == 0) {
     {  
         gettimeofday(&first, NULL);         gettimeofday(&first, NULL);
     }     }
     gettimeofday(&now, NULL);     gettimeofday(&now, NULL);
  
     if (((now.tv_sec - first.tv_sec) > IDLE_LIMIT) &&     if (((now.tv_sec - first.tv_sec) > IDLE_LIMIT) &&
         ((now.tv_sec - last.tv_sec) > IDLE_LIMIT))         ((now.tv_sec - last.tv_sec) > IDLE_LIMIT)) {
     {  
         gettimeofday(&last, NULL);         gettimeofday(&last, NULL);
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
             "Checking for Idle providers to unload.");             "Checking for Idle providers to unload.");
         try        try {
         {  
             _provider_ctrl(UNLOAD_IDLE_PROVIDERS, this, (void *)0);             _provider_ctrl(UNLOAD_IDLE_PROVIDERS, this, (void *)0);
         }         }
         catch(...)        catch (...) {
         {  
             PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,             PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
                 "Caught unexpected exception from UNLOAD_IDLE_PROVIDERS.");                 "Caught unexpected exception from UNLOAD_IDLE_PROVIDERS.");
         }         }
Line 509 
Line 467 
  
 CMPIProvider* CMPILocalProviderManager::_initProvider( CMPIProvider* CMPILocalProviderManager::_initProvider(
     CMPIProvider * provider,     CMPIProvider * provider,
     const String & moduleFileName)                                                       const String & moduleFileName) {
 {  
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "_initProvider");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "_initProvider");
  
     CMPIProviderModule *module = 0;     CMPIProviderModule *module = 0;
Line 527 
Line 484 
                          "Loading/Linking Provider Module " + moduleFileName);                          "Loading/Linking Provider Module " + moduleFileName);
  
         // load the provider         // load the provider
         try        try {
         {  
             base = module->load(provider->_name);             base = module->load(provider->_name);
         }         }
         catch(...)        catch (...) {
         {  
             PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,             PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
                            "Exception caught Loading/Linking Provider Module " +                            "Exception caught Loading/Linking Provider Module " +
                            moduleFileName);                            moduleFileName);
Line 556 
Line 511 
         AutoMutex pr_lock(provider->_statusMutex);         AutoMutex pr_lock(provider->_statusMutex);
  
         // check provider status         // check provider status
         if (provider->_status == CMPIProvider::UNINITIALIZED)        if (provider->_status == CMPIProvider::UNINITIALIZED) {
         {  
             CIMOMHandle *cimomHandle =  new CIMOMHandle();             CIMOMHandle *cimomHandle =  new CIMOMHandle();
             provider->set(module, base, cimomHandle);             provider->set(module, base, cimomHandle);
             provider->_quantum=0;             provider->_quantum=0;
  
             try           try {
             {  
                 provider->initialize(*(provider->_cimom_handle));                 provider->initialize(*(provider->_cimom_handle));
                 undoModuleLoad = false;                 undoModuleLoad = false;
             }             }
             catch(...)           catch (...) {
             {  
                 _providers.remove(provider->getName());                 _providers.remove(provider->getName());
                 // delete the cimom handle                 // delete the cimom handle
                 delete provider->_cimom_handle;                 delete provider->_cimom_handle;
Line 580 
Line 532 
     }  // unlock the provider mutex     }  // unlock the provider mutex
  
     // if we did not initialize the provider, unload the provider module     // if we did not initialize the provider, unload the provider module
     if (undoModuleLoad)     if (undoModuleLoad) {
     {  
         // lock the providerTable mutex         // lock the providerTable mutex
         AutoMutex lock(_providerTableMutex);         AutoMutex lock(_providerTableMutex);
  
Line 594 
Line 545 
 } }
  
  
 void CMPILocalProviderManager::_unloadProvider( CMPIProvider * provider)  void CMPILocalProviderManager::_unloadProvider( CMPIProvider * provider) {
 {  
     //     //
     // NOTE:  It is the caller's responsibility to make sure that     // NOTE:  It is the caller's responsibility to make sure that
     // the ProviderTable mutex is locked before calling this method.     // the ProviderTable mutex is locked before calling this method.
Line 605 
Line 555 
     PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,     PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
                      "Unloading Provider " + provider->_name );                      "Unloading Provider " + provider->_name );
  
     if ( provider->_current_operations.value())     if ( provider->_current_operations.value()) {
     {  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
                          "Provider cannot be unloaded due to pending operations: " +                          "Provider cannot be unloaded due to pending operations: " +
                          provider->_name );                          provider->_name );
     }     }
     else     else {
     {  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
                          "Terminating Provider " + provider->_name );                          "Terminating Provider " + provider->_name );
  
         // lock the provider mutex         // lock the provider mutex
         AutoMutex pr_lock(provider->_statusMutex);         AutoMutex pr_lock(provider->_statusMutex);
  
         try        try {
         {  
             provider->terminate();             provider->terminate();
         }         }
         catch(...)        catch (...) {
         {  
             PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL3,             PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL3,
                              "Error occured terminating CMPI provider " + provider->_name );                              "Error occured terminating CMPI provider " + provider->_name );
         }         }
Line 653 
Line 599 
 } }
  
 CMPIProvider * CMPILocalProviderManager::_lookupProvider( CMPIProvider * CMPILocalProviderManager::_lookupProvider(
     const String & providerName)                                                          const String & providerName) {
 {  
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "_lookupProvider");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "_lookupProvider");
  
     // lock the providerTable mutex     // lock the providerTable mutex
Line 662 
Line 607 
  
     // look up provider in cache     // look up provider in cache
     CMPIProvider * pr = 0;     CMPIProvider * pr = 0;
     if ( true == _providers.lookup(providerName, pr) )     if ( true == _providers.lookup(providerName, pr) ) {
     {  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
                          "Found Provider " + providerName +                          "Found Provider " + providerName +
                          " in CMPI Provider Manager Cache");                          " in CMPI Provider Manager Cache");
     }     }
     else     else {
     {  
         // create provider         // create provider
         pr = new CMPIProvider(providerName, 0, 0);         pr = new CMPIProvider(providerName, 0, 0);
  
Line 686 
Line 629 
  
  
 CMPIProviderModule * CMPILocalProviderManager::_lookupModule( CMPIProviderModule * CMPILocalProviderManager::_lookupModule(
     const String & moduleFileName)                                                              const String & moduleFileName) {
 {  
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "_lookupModule");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "_lookupModule");
  
     // look up provider module in cache     // look up provider module in cache
     CMPIProviderModule * module = 0;     CMPIProviderModule * module = 0;
  
     if ( true == _modules.lookup(moduleFileName, module) )     if ( true == _modules.lookup(moduleFileName, module) ) {
     {  
         // found provider module in cache         // found provider module in cache
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
                          "Found Provider Module" + moduleFileName +                          "Found Provider Module" + moduleFileName +
                          " in Provider Manager Cache");                          " in Provider Manager Cache");
  
    }    }
    else     else {
    {  
         // provider module not found in cache, create provider module         // provider module not found in cache, create provider module
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
                          "Creating CMPI Provider Module " + moduleFileName);                          "Creating CMPI Provider Module " + moduleFileName);

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