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

Diff for /pegasus/src/Pegasus/ProviderManager2/Default/DefaultProviderManager.cpp between version 1.76 and 1.87

version 1.76, 2006/10/10 18:27:09 version 1.87, 2008/08/28 17:24:45
Line 40 
Line 40 
 #include <Pegasus/Common/StatisticalData.h> #include <Pegasus/Common/StatisticalData.h>
 #include <Pegasus/Common/Logger.h> #include <Pegasus/Common/Logger.h>
 #include <Pegasus/Common/MessageLoader.h> #include <Pegasus/Common/MessageLoader.h>
   #include <Pegasus/Common/FileSystem.h>
 #include <Pegasus/Common/PegasusVersion.h> #include <Pegasus/Common/PegasusVersion.h>
 #include <Pegasus/Common/Constants.h> #include <Pegasus/Common/Constants.h>
  
Line 114 
Line 115 
         case CIM_DELETE_SUBSCRIPTION_REQUEST_MESSAGE:         case CIM_DELETE_SUBSCRIPTION_REQUEST_MESSAGE:
         case CIM_EXPORT_INDICATION_REQUEST_MESSAGE:         case CIM_EXPORT_INDICATION_REQUEST_MESSAGE:
         {         {
               ProviderIdContainer providerId =
                   request->operationContext.get(ProviderIdContainer::NAME);
   
             // resolve provider name             // resolve provider name
             ProviderName name = _resolveProviderName(              ProviderName name = _resolveProviderName(providerId);
                 request->operationContext.get(ProviderIdContainer::NAME));  
  
             // get cached or load new provider module             // get cached or load new provider module
             ProviderOperationCounter poc(             ProviderOperationCounter poc(
                 _getProvider(name.getPhysicalName(), name.getLogicalName()));                  _getProvider(
                       name.getPhysicalName(),
                       name.getModuleName(),
                       name.getLogicalName()));
  
             response = poc.GetProvider().processMessage(request);             response = poc.GetProvider().processMessage(request);
             break;             break;
Line 144 
Line 150 
             response = _handleSubscriptionInitCompleteRequest(request);             response = _handleSubscriptionInitCompleteRequest(request);
             break;             break;
  
 // Note: The PG_Provider AutoStart property is not yet supported  
 #if 0  
         case CIM_INITIALIZE_PROVIDER_REQUEST_MESSAGE:  
         {  
             // resolve provider name  
             ProviderName name = _resolveProviderName(  
                 request->operationContext.get(ProviderIdContainer::NAME));  
   
             // get cached or load new provider module  
             ProviderOperationCounter poc(  
                 _getProvider(name.getPhysicalName(), name.getLogicalName()));  
   
             break;  
         }  
 #endif  
   
         default:         default:
             PEGASUS_ASSERT(0);             PEGASUS_ASSERT(0);
             break;             break;
Line 167 
Line 157 
     }     }
     catch (CIMException& e)     catch (CIMException& e)
     {     {
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,          PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1,"CIMException: %s",
             "CIMException: " + e.getMessage());              (const char*)e.getMessage().getCString()));
         response = request->buildResponse();         response = request->buildResponse();
         response->cimException = PEGASUS_CIM_EXCEPTION_LANG(         response->cimException = PEGASUS_CIM_EXCEPTION_LANG(
             e.getContentLanguages(), e.getCode(), e.getMessage());             e.getContentLanguages(), e.getCode(), e.getMessage());
     }     }
     catch (Exception& e)     catch (Exception& e)
     {     {
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,          PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1,"Exception: %s",
             "Exception: " + e.getMessage());              (const char*)e.getMessage().getCString()));
         response = request->buildResponse();         response = request->buildResponse();
         response->cimException = PEGASUS_CIM_EXCEPTION_LANG(         response->cimException = PEGASUS_CIM_EXCEPTION_LANG(
             e.getContentLanguages(), CIM_ERR_FAILED, e.getMessage());             e.getContentLanguages(), CIM_ERR_FAILED, e.getMessage());
     }     }
     catch (...)     catch (...)
     {     {
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,          PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL1,
             "Exception: Unknown");             "Exception: Unknown");
         response = request->buildResponse();         response = request->buildResponse();
         response->cimException = PEGASUS_CIM_EXCEPTION(         response->cimException = PEGASUS_CIM_EXCEPTION(
Line 221 
Line 211 
         //         //
         Array<CIMInstance> providerInstances = request->providers;         Array<CIMInstance> providerInstances = request->providers;
  
         String physicalName = _resolvePhysicalName(  
             mInstance.getProperty(  
                 mInstance.findProperty("Location")).getValue().toString());  
   
         for (Uint32 i = 0, n = providerInstances.size(); i < n; i++)         for (Uint32 i = 0, n = providerInstances.size(); i < n; i++)
         {         {
             String pName;             String pName;
Line 232 
Line 218 
                 providerInstances[i].findProperty("Name")).                 providerInstances[i].findProperty("Name")).
                     getValue().get(pName);                     getValue().get(pName);
  
             Sint16 ret_value = _disableProvider(pName);              Sint16 ret_value = _disableProvider(moduleName, pName);
  
             if (ret_value == 0)             if (ret_value == 0)
             {             {
Line 255 
Line 241 
     }     }
     catch (CIMException & e)     catch (CIMException & e)
     {     {
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,          PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1,"CIMException: %s",
                          "Exception: " + e.getMessage());              (const char*)e.getMessage().getCString()));
         cimException = e;         cimException = e;
     }     }
     catch (Exception & e)     catch (Exception & e)
     {     {
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,          PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1,"Exception: %s",
             "Exception: " + e.getMessage());              (const char*)e.getMessage().getCString()));
         cimException = CIMException(CIM_ERR_FAILED, e.getMessage());         cimException = CIMException(CIM_ERR_FAILED, e.getMessage());
     }     }
     catch (...)     catch (...)
     {     {
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,          PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL1,
             "Exception: Unknown");             "Exception: Unknown");
         cimException = PEGASUS_CIM_EXCEPTION_L(         cimException = PEGASUS_CIM_EXCEPTION_L(
             CIM_ERR_FAILED,             CIM_ERR_FAILED,
Line 377 
Line 363 
 { {
     String providerName;     String providerName;
     String fileName;     String fileName;
     String interfaceName;      String moduleName;
     CIMValue genericValue;     CIMValue genericValue;
  
       genericValue = providerId.getModule().getProperty(
           providerId.getModule().findProperty("Name")).getValue();
       genericValue.get(moduleName);
   
     genericValue = providerId.getProvider().getProperty(     genericValue = providerId.getProvider().getProperty(
         providerId.getProvider().findProperty("Name")).getValue();         providerId.getProvider().findProperty("Name")).getValue();
     genericValue.get(providerName);     genericValue.get(providerName);
Line 387 
Line 377 
     genericValue = providerId.getModule().getProperty(     genericValue = providerId.getModule().getProperty(
         providerId.getModule().findProperty("Location")).getValue();         providerId.getModule().findProperty("Location")).getValue();
     genericValue.get(fileName);     genericValue.get(fileName);
     fileName = _resolvePhysicalName(fileName);  
  
     // ATTN: This attribute is probably not required      String resolvedFileName = _resolvePhysicalName(fileName);
     genericValue = providerId.getModule().getProperty(  
         providerId.getModule().findProperty("InterfaceType")).getValue();  
     genericValue.get(interfaceName);  
  
     return ProviderName(providerName, fileName, interfaceName, 0);      if (resolvedFileName == String::EMPTY)
       {
           // Provider library not found
           throw Exception(MessageLoaderParms(
               "ProviderManager.ProviderManagerService.PROVIDER_FILE_NOT_FOUND",
               "File \"$0\" was not found for provider module \"$1\".",
               FileSystem::buildLibraryFileName(fileName), moduleName));
       }
   
       return ProviderName(moduleName, providerName, resolvedFileName);
 } }
  
 ProviderOperationCounter DefaultProviderManager::_getProvider( ProviderOperationCounter DefaultProviderManager::_getProvider(
     const String& moduleFileName,     const String& moduleFileName,
       const String& moduleName,
     const String& providerName)     const String& providerName)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
         "DefaultProviderManager::_getProvider");         "DefaultProviderManager::_getProvider");
  
     ProviderMessageHandler* pr = _lookupProvider(providerName);      ProviderMessageHandler* pr = _lookupProvider(moduleName, providerName);
  
     if (!pr->status.isInitialized())     if (!pr->status.isInitialized())
     {     {
Line 422 
Line 418 
  
     ProviderOperationCounter poc(pr);     ProviderOperationCounter poc(pr);
  
     PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,      PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Returning Provider %s",
         "Returning Provider " + providerName);          (const char*)providerName.getCString()));
  
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
     return poc;     return poc;
 } }
  
 ProviderMessageHandler* DefaultProviderManager::_lookupProvider( ProviderMessageHandler* DefaultProviderManager::_lookupProvider(
       const String& moduleName,
     const String& providerName)     const String& providerName)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
Line 438 
Line 435 
     // lock the providerTable mutex     // lock the providerTable mutex
     AutoMutex lock(_providerTableMutex);     AutoMutex lock(_providerTableMutex);
  
       // Construct the lookup key. We need a compound key to differentiate
       // providers with the same name from different modules. The size field is
       // added to handle the unlikely case when moduleName+providerName
       // produce identical strings but define different providers.
       char buffer[12];
       sprintf(buffer, "%u:", providerName.size());
       const String key = buffer + moduleName + ":" + providerName;
   
     // look up provider in cache     // look up provider in cache
     ProviderMessageHandler* pr = 0;     ProviderMessageHandler* pr = 0;
     if (_providers.lookup(providerName, pr))      if (_providers.lookup(key, pr))
     {     {
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,          PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
             "Found Provider " + providerName + " in Provider Manager Cache");              "Found Provider %s in Provider Manager Cache",
               (const char*)providerName.getCString()));
     }     }
     else     else
     {     {
         // create provider         // create provider
         pr = new ProviderMessageHandler(         pr = new ProviderMessageHandler(
             providerName, 0, _indicationCallback, _responseChunkCallback,              moduleName, providerName,
               0, _indicationCallback, _responseChunkCallback,
             _subscriptionInitComplete);             _subscriptionInitComplete);
  
         // insert provider in provider table         // insert provider in provider table
         _providers.insert(providerName, pr);          _providers.insert(key, pr);
  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,          PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Created provider %s",
             "Created provider " + pr->getName());              (const char*)pr->getName().getCString()));
     }     }
  
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
Line 485 
Line 492 
         return provider;         return provider;
     }     }
  
     PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,      PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
         "Loading/Linking Provider Module " + moduleFileName);          "Loading/Linking Provider Module %s",
           (const char*)moduleFileName.getCString()));
  
     // load the provider     // load the provider
     try     try
Line 495 
Line 503 
     }     }
     catch (...)     catch (...)
     {     {
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,          PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1,
             "Exception caught Loading/Linking Provider Module " +              "Exception caught Loading/Linking Provider Module %s",
             moduleFileName);              (const char*)moduleFileName.getCString()));
         PEG_METHOD_EXIT();         PEG_METHOD_EXIT();
         throw;         throw;
     }     }
  
     // initialize the provider     // initialize the provider
     PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,      PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL2, "Initializing Provider %s",
         "Initializing Provider " + provider->getName());          (const char*)provider->getName().getCString()));
  
     CIMOMHandle *cimomHandle = new CIMOMHandle();     CIMOMHandle *cimomHandle = new CIMOMHandle();
     provider->status.setCIMOMHandle(cimomHandle);     provider->status.setCIMOMHandle(cimomHandle);
Line 568 
Line 576 
     if (_modules.lookup(moduleFileName, module))     if (_modules.lookup(moduleFileName, module))
     {     {
         // found provider module in cache         // found provider module in cache
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,          PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
             "Found Provider Module " + moduleFileName +              "Found Provider Module %s in Provider Manager Cache",
             " in Provider Manager Cache");              (const char*)moduleFileName.getCString()));
     }     }
     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((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
             "Creating Provider Module " + moduleFileName);              "Creating Provider Module %s",
               (const char*)moduleFileName.getCString()));
  
         module = new ProviderModule(moduleFileName);         module = new ProviderModule(moduleFileName);
  
Line 596 
Line 605 
     try     try
     {     {
         AutoMutex lock(_providerTableMutex);         AutoMutex lock(_providerTableMutex);
         Tracer::trace(TRC_PROVIDERMANAGER, Tracer::LEVEL4,          PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
             "Number of providers in _providers table = %d", _providers.size());              "Number of 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++)
Line 612 
Line 621 
     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_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL1,
             "Unexpected Exception in hasActiveProviders.");             "Unexpected Exception in hasActiveProviders.");
         PEG_METHOD_EXIT();         PEG_METHOD_EXIT();
         return true;         return true;
Line 658 
Line 667 
             struct timeval providerTime = {0, 0};             struct timeval providerTime = {0, 0};
             provider->status.getLastOperationEndTime(&providerTime);             provider->status.getLastOperationEndTime(&providerTime);
  
             PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,              PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
                 "provider->status.isIdle() returns: " +                  "provider->status.isIdle() returns: %s",
                 CIMValue(provider->status.isIdle()).toString());                  (const char*)CIMValue(provider->status.isIdle())
                          .toString().getCString()));
  
             if (provider->status.isIdle() &&             if (provider->status.isIdle() &&
                 ((now.tv_sec - providerTime.tv_sec) > ((Sint32)IDLE_LIMIT)))                  ((now.tv_sec - providerTime.tv_sec) >
                    ((Sint32)PEGASUS_PROVIDER_IDLE_TIMEOUT_SECONDS)))
             {             {
                 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,                  PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL3,
                     "Unloading idle provider: " + provider->getName());                      "Unloading idle provider: %s",
                       (const char*)provider->getName().getCString()));
                 _unloadProvider(provider);                 _unloadProvider(provider);
             }             }
         }         }
     }     }
     catch (...)     catch (...)
     {     {
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,          PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL1,
             "Caught unexpected exception in unloadIdleProviders.");             "Caught unexpected exception in unloadIdleProviders.");
     }     }
  
Line 689 
Line 701 
     {     {
         AutoMutex lock(_providerTableMutex);         AutoMutex lock(_providerTableMutex);
  
         Tracer::trace(TRC_PROVIDERMANAGER, Tracer::LEVEL4,          PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
             "providers in cache = %d", _providers.size());              "providers in cache = %d", _providers.size()));
  
         for (ProviderTable::Iterator i = _providers.start(); i != 0; i++)         for (ProviderTable::Iterator i = _providers.start(); i != 0; i++)
         {         {
             ProviderMessageHandler* provider = i.value();             ProviderMessageHandler* provider = i.value();
             PEGASUS_ASSERT(provider != 0);             PEGASUS_ASSERT(provider != 0);
  
             AutoMutex lock(provider->status.getStatusMutex());              AutoMutex lock2(provider->status.getStatusMutex());
  
             if (provider->status.isInitialized())             if (provider->status.isInitialized())
             {             {
Line 707 
Line 719 
     }     }
     catch (...)     catch (...)
     {     {
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,          PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
             "Unexpected Exception in _shutdownAllProviders().");             "Unexpected Exception in _shutdownAllProviders().");
     }     }
  
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
 } }
  
 Sint16 DefaultProviderManager::_disableProvider(const String& providerName)  Sint16 DefaultProviderManager::_disableProvider(
       const String& moduleName,
       const String& providerName)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
         "DefaultProviderManager::_disableProvider");         "DefaultProviderManager::_disableProvider");
  
     ProviderMessageHandler* pr = _lookupProvider(providerName);      ProviderMessageHandler* pr = _lookupProvider(moduleName, providerName);
     if (!pr->status.isInitialized())     if (!pr->status.isInitialized())
     {     {
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,          PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL2,
             "Provider " + providerName + " is not loaded");              "Provider %s is not loaded",
               (const char*)providerName.getCString()));
         PEG_METHOD_EXIT();         PEG_METHOD_EXIT();
         return 1;         return 1;
     }     }
  
     PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,      PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Disable Provider %s",
         "Disable Provider " + pr->getName());          (const char*)pr->getName().getCString()));
     //     //
     // Check to see if there are pending requests. If there are pending     // Check to see if there are pending requests. If there are pending
     // requests and the disable timeout has not expired, loop and wait one     // requests and the disable timeout has not expired, loop and wait one
Line 746 
Line 761 
     // There are still pending requests, do not disable     // There are still pending requests, do not disable
     if (pr->status.numCurrentOperations() > 0)     if (pr->status.numCurrentOperations() > 0)
     {     {
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,          PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
             "Disable failed since there are pending requests.");             "Disable failed since there are pending requests.");
         PEG_METHOD_EXIT();         PEG_METHOD_EXIT();
         return 0;         return 0;
Line 758 
Line 773 
  
         if (pr->status.isInitialized())         if (pr->status.isInitialized())
         {         {
             PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,              PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
                 "Unloading Provider " + pr->getName());                  "Unloading Provider %s",
                   (const char*)pr->getName().getCString()));
             _unloadProvider(pr);             _unloadProvider(pr);
         }         }
     }     }
     catch (...)     catch (...)
     {     {
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,          PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL2,
             "Unload provider failed " + pr->getName());              "Unload provider failed %s",
               (const char*)pr->getName().getCString()));
         PEG_METHOD_EXIT();         PEG_METHOD_EXIT();
         return -1;         return -1;
     }     }
Line 788 
Line 805 
  
     if (provider->status.numCurrentOperations() > 0)     if (provider->status.numCurrentOperations() > 0)
     {     {
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,          PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
             "Provider cannot be unloaded due to pending operations: " +              "Provider cannot be unloaded due to pending operations: %s",
             provider->getName());              (const char*)provider->getName().getCString()));
     }     }
     else     else
     {     {
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,          PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
             "Terminating Provider " + provider->getName());              "Terminating Provider %s",
               (const char*)provider->getName().getCString()));
  
         provider->terminate();         provider->terminate();
  
         // unload provider module         // unload provider module
         PEGASUS_ASSERT(provider->status.getModule() != 0);         PEGASUS_ASSERT(provider->status.getModule() != 0);
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,          PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL3,
             "Unloading provider module: " + provider->getName());              "Unloading provider module: %s",
               (const char*)provider->getName().getCString()));
         provider->status.getModule()->unloadModule();         provider->status.getModule()->unloadModule();
  
         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,          PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL3,
             "DefaultProviderManager:  Unloaded provider $0",              "DefaultProviderManager: Unloaded provider %s",
             provider->getName());              (const char*)provider->getName().getCString()));
  
         // NOTE: The "delete provider->status.getCIMOMHandle()" operation         // NOTE: The "delete provider->status.getCIMOMHandle()" operation
         //   was moved to be called after the unloadModule() call above         //   was moved to be called after the unloadModule() call above
Line 821 
Line 840 
         //   above the unloadModule() call. See bugzilla 3669 for details.         //   above the unloadModule() call. See bugzilla 3669 for details.
  
         // delete the cimom handle         // delete the cimom handle
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,          PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
             "Destroying provider's CIMOMHandle: " + provider->getName());              "Destroying provider's CIMOMHandle: %s",
               (const char*)provider->getName().getCString()));
         delete provider->status.getCIMOMHandle();         delete provider->status.getCIMOMHandle();
  
         // set provider status to uninitialized         // set provider status to uninitialized

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