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

Diff for /pegasus/src/Pegasus/ProviderManager2/JMPI/JMPILocalProviderManager.cpp between version 1.8 and 1.9

version 1.8, 2005/02/25 21:44:19 version 1.9, 2005/06/14 18:17:23
Line 48 
Line 48 
 PEGASUS_USING_STD; PEGASUS_USING_STD;
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
   int JMPILocalProviderManager::trace=0;
   
   #ifdef PEGASUS_DEBUG
   #define DDD(x) if (JMPILocalProviderManager::trace) x;
   #else
   #define DDD(x)
   #endif
   
 JMPILocalProviderManager::JMPILocalProviderManager(void) JMPILocalProviderManager::JMPILocalProviderManager(void)
     : _idle_timeout(IDLE_LIMIT)     : _idle_timeout(IDLE_LIMIT)
 { {
   #ifdef PEGASUS_DEBUG
      if (getenv("PEGASUS_JMPI_TRACE"))
         JMPILocalProviderManager::trace=1;
      else
         JMPILocalProviderManager::trace=0;
   #else
      JMPILocalProviderManager::trace=0;
   #endif
 } }
  
 JMPILocalProviderManager::~JMPILocalProviderManager(void) JMPILocalProviderManager::~JMPILocalProviderManager(void)
Line 62 
Line 78 
  
 Sint32 JMPILocalProviderManager::_provider_ctrl(CTRL code, void *parm, void *ret) Sint32 JMPILocalProviderManager::_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 74 
Line 89 
  
     case GET_PROVIDER:     case GET_PROVIDER:
         {         {
             PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,              PEG_TRACE_STRING(TRC_PROVIDERMANAGER,
                                Tracer::LEVEL2,
                 "_provider_ctrl::GET_PROVIDER");                 "_provider_ctrl::GET_PROVIDER");
  
             JMPIProvider *pr = NULL;              String providerName = *(parms->providerName);
               String moduleFileName = *(parms->fileName);
               String interfaceName = *(parms->interfaceName);
   
               DDD(PEGASUS_STD(cout)
                   <<"--- JMPILocalProviderManager::_provider_ctrl: GET_PROVIDER "
                   <<providerName
                   <<PEGASUS_STD(endl));
   
             JMPIProvider::OpProviderHolder* ph =             JMPIProvider::OpProviderHolder* ph =
                   reinterpret_cast< JMPIProvider::OpProviderHolder* >( ret );                   reinterpret_cast< JMPIProvider::OpProviderHolder* >( ret );
               JMPIProviderModule *newModule = NULL;
               JMPIProviderModule *module = NULL;
               JMPIProvider *newProvider = NULL;
               JMPIProvider *provider = NULL;
               ProviderVector base;
  
               try
             if(true == _providers.lookup( *(parms->providerName), pr ))  
             {             {
                 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,                 {
                     "Found JMPIProvider " + *(parms->providerName) + " in JMPIProvider Manager Cache");                    AutoMutex lock (_providerTableMutex);
  
                 ph->SetProvider( pr );                    if (true == _providers.lookup(providerName, provider))
 //                ph->GetProvider().update_idle_timer();                    {
                         PEG_TRACE_STRING(TRC_PROVIDERMANAGER,
                                          Tracer::LEVEL4,
                                          "Found JMPIProvider "
                                          + providerName
                                          + " in JMPIProvider Manager Cache");
                         DDD(PEGASUS_STD(cout)
                             <<"--- JMPILocalProviderManager::_provider_ctrl: Found "
                             <<providerName
                             <<" in JMPIProvider Manager Cache"
                             <<PEGASUS_STD(endl));
                         DDD(PEGASUS_STD(cout)
                             <<"--- JMPILocalProviderManager::_provider_ctrl:"
                               " setting provider to "
                             <<PEGASUS_STD(hex)
                             <<(int)provider
                             <<PEGASUS_STD(dec)
                             <<PEGASUS_STD(endl));
   
                         ph->SetProvider(provider);
   
   //////////////////////ph->GetProvider().update_idle_timer();
                 break;                 break;
             }             }
  
                     PEG_TRACE_STRING(TRC_PROVIDERMANAGER,
                                      Tracer::LEVEL4,
                                      "Creating JMPIProvider " + providerName );
                     DDD(PEGASUS_STD(cout)
                         <<"--- JMPILocalProviderManager::_provider_ctrl: Creating "
                         <<providerName
                         <<PEGASUS_STD(endl));
   
                     if (false == _modules.lookup(moduleFileName, module))
                     {
                         PEG_TRACE_STRING(TRC_PROVIDERMANAGER,
                                          Tracer::LEVEL4,
                                          "Creating JMPIProvider Module "
                                          + moduleFileName );
                         DDD(PEGASUS_STD(cout)
                             <<"--- JMPILocalProviderManager::_provider_ctrl: "
                               "Creating module "
                               <<moduleFileName
                               <<PEGASUS_STD(endl));
   
                         newModule = new JMPIProviderModule(moduleFileName,
                                                            interfaceName);
   
                         if (0 == newModule)
                         {
                             PEG_TRACE_STRING(TRC_PROVIDERMANAGER,
                                              Tracer::LEVEL4,
                                              "new JMPIProviderModule is NULL!");
                             DDD(PEGASUS_STD(cout)
                                 <<"--- JMPILocalProviderManager::_provider_ctrl:"
                                   " new JMPIProviderModule is NULL!"
                                   <<PEGASUS_STD(endl));
  
             PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,                            throw NullPointer();
                 "Creating JMPIProvider " + *(parms->providerName) );                        }
             JMPIProviderModule *module;  
   
             if(false  == _modules.lookup(*(parms->fileName), module))  
             {  
                 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
                     "Creating JMPIProvider Module " + *(parms->fileName) );  
  
                 module = new JMPIProviderModule(*(parms->fileName),*(parms->interfaceName));                        module = newModule;
  
                 _modules.insert((*parms->fileName), module);                        _modules.insert(moduleFileName, module);
             }             }
             else             else
             {             {
                 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,                        PEG_TRACE_STRING(TRC_PROVIDERMANAGER,
                     "Using Cached  JMPIProvider Module " + *(parms->fileName) );                                         Tracer::LEVEL4,
                                          "Using Cached JMPIProvider Module "
                                          + moduleFileName);
                         DDD(PEGASUS_STD(cout)
                             <<"--- JMPILocalProviderManager::_provider_ctrl: "
                             "Using cached "
                             <<moduleFileName
                             <<PEGASUS_STD(endl));
                     }
             }             }
  
                  PEG_TRACE_STRING(TRC_PROVIDERMANAGER,
                                   Tracer::LEVEL4,
                                   "Loading/Linking JMPIProvider Module "
                                   + moduleFileName );
                  DDD(PEGASUS_STD(cout)
                      <<"--- JMPILocalProviderManager::_provider_ctrl:"
                        " Loading/Linking module "
                        <<moduleFileName
                        <<PEGASUS_STD(endl));
  
             PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
                 "Loading/Linking JMPIProvider Module " + *(parms->fileName) );  
   
             ProviderVector base ;  
             try             try
             {             {
                 base = module->load(*(parms->fileName));                     base = module->load(moduleFileName);
             }             }
             catch(...)             catch(...)
             {             {
                 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,                     PEG_TRACE_STRING(TRC_PROVIDERMANAGER,
                     "Exception caught Loading/Linking JMPIProvider Module " + *(parms->fileName) );                                      Tracer::LEVEL4,
                                       "Exception caught Loading/Linking"
                                       " JMPIProvider Module "
                                       + moduleFileName );
                      DDD(PEGASUS_STD(cout)
                          <<"--- JMPILocalProviderManager::_provider_ctrl: "
                          "Exception caught Loading/Linking module "
                          <<moduleFileName
                          <<PEGASUS_STD(endl));
   
                 throw;                 throw;
             }             }
  
             // create provider module             // create provider module
                  newProvider = new JMPIProvider(providerName, module, &base);
                  if (0 == newProvider)
                  {
                      PEG_TRACE_STRING(TRC_PROVIDERMANAGER,
                                       Tracer::LEVEL4,
                                       "new JMPIProvider is NULL!");
                      DDD(PEGASUS_STD(cout)
                          <<"--- JMPILocalProviderManager::_provider_ctrl: "
                            "new JMPIProvider is NULL!"
                          <<PEGASUS_STD(endl));
  
             MessageQueue * queue = MessageQueue::lookup(PEGASUS_QUEUENAME_PROVIDERMANAGER_CPP);  
             PEGASUS_ASSERT(queue != 0);  
             MessageQueueService * service = dynamic_cast<MessageQueueService *>(queue);  
             PEGASUS_ASSERT(service != 0);  
             pr = new JMPIProvider(*(parms->providerName), module, &base);  
             if(0 == (pr->_cimom_handle =  new CIMOMHandle()))  
                 throw NullPointer();                 throw NullPointer();
             pr->_quantum=0;                 }
  
                  provider = newProvider;
  
             PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,                 if (0 == (provider->_cimom_handle = new CIMOMHandle()))
                 "Loading JMPIProvider " +  pr->_name);                 {
                      PEG_TRACE_STRING(TRC_PROVIDERMANAGER,
                                       Tracer::LEVEL4,
                                       "_cimom_handle is NULL!");
                      DDD(PEGASUS_STD(cout)
                          <<"--- JMPILocalProviderManager::_provider_ctrl:"
                            " _cimom_handle is NULL!"
                            <<PEGASUS_STD(endl));
   
                      throw NullPointer();
                  }
   
                  provider->_quantum = 0;
   
                  {
                     AutoMutex lock(provider->_statusMutex);
   
                     PEG_TRACE_STRING(TRC_PROVIDERMANAGER,
                                      Tracer::LEVEL2,
                                      "Loading JMPIProvider "
                                      +  provider->_name);
                     DDD(PEGASUS_STD(cout)
                         <<"--- JMPILocalProviderManager::_provider_ctrl:"
                           " Loading "
                           <<provider->_name
                           <<PEGASUS_STD(endl));
             try             try
             {             {
                 pr->initialize(*(pr->_cimom_handle));                        provider->initialize(*(provider->_cimom_handle));
             }             }
             catch(...)             catch(...)
             {             {
                 delete pr->_cimom_handle;                        PEG_TRACE_STRING(TRC_PROVIDERMANAGER,
                 delete pr;                                         Tracer::LEVEL4,
                                          "Exception caught calling initialize!");
                         DDD(PEGASUS_STD(cout)
                             <<"--- JMPILocalProviderManager::_provider_ctrl:"
                               " Exception caught calling initialize!"
                               <<PEGASUS_STD(endl));
   
                 throw UninitializedObjectException();                 throw UninitializedObjectException();
             }             }
                  }
               }
               catch (...)
               {
                  if (newModule)
                  {
                     _modules.remove(moduleFileName);
                  }
   
                  delete newModule;
   
                  if (newProvider)
                  {
                     delete newProvider->_cimom_handle;
                  }
   
                  delete newProvider;
  
 //            pr->update_idle_timer();                 throw;
               }
  
             _providers.insert(*(parms->providerName), pr);  
  
   //          provider->update_idle_timer();
  
             ph->SetProvider( pr );              _providers.insert(providerName, provider);
   
               DDD(PEGASUS_STD(cout)
                   <<"--- JMPILocalProviderManager::_provider_ctrl:"
                     "setting provider to "
                     <<PEGASUS_STD(hex)
                     <<(int)provider
                     <<PEGASUS_STD(dec)
                     <<PEGASUS_STD(endl));
   
               ph->SetProvider( provider );
             break;             break;
         }         }
  
     case UNLOAD_PROVIDER:     case UNLOAD_PROVIDER:
         {         {
               DDD(PEGASUS_STD(cout)
                   <<"--- JMPILocalProviderManager::_provider_ctrl: "
                     "UNLOAD_PROVIDER"
                     <<PEGASUS_STD(endl));
             break;             break;
         }         }
  
     case LOOKUP_PROVIDER:     case LOOKUP_PROVIDER:
         {         {
               PEG_TRACE_STRING(TRC_PROVIDERMANAGER,
             PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,                               Tracer::LEVEL2,
                 "_provider_ctrl::LOOKUP_PROVIDER");                 "_provider_ctrl::LOOKUP_PROVIDER");
               DDD(PEGASUS_STD(cout)
                   <<"--- JMPILocalProviderManager::_provider_ctrl: "
                   "LOOKUP_PROVIDER "
                   <<*(parms->providerName)
                   <<PEGASUS_STD(endl));
   
               AutoMutex lock (_providerTableMutex);
  
             if(true == _providers.lookup(*(parms->providerName),             if(true == _providers.lookup(*(parms->providerName),
                 *(reinterpret_cast<JMPIProvider * *>(ret))))                 *(reinterpret_cast<JMPIProvider * *>(ret))))
             {             {
                 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,                  PEG_TRACE_STRING(TRC_PROVIDERMANAGER,
                     "Found JMPIProvider in cache: " +                                   Tracer::LEVEL4,
                     *(parms->providerName));                                   "Found JMPIProvider in cache: "
                                    + *(parms->providerName));
  
 //                (*(reinterpret_cast<JMPIProvider * *>(ret)))->update_idle_timer();  ////////////////(*(reinterpret_cast<JMPIProvider * *>(ret)))->update_idle_timer();
             }             }
             else             else
             {             {
                   PEG_TRACE_STRING(TRC_PROVIDERMANAGER,
                 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,                                   Tracer::LEVEL4,
                     "Could not find  JMPIProvider in cache: " +                                   "Could not find  JMPIProvider in cache: "
                     *(parms->providerName));                                   + *(parms->providerName));
                 ccode = -1;                 ccode = -1;
             }             }
  
Line 196 
Line 369 
  
     case LOOKUP_MODULE:     case LOOKUP_MODULE:
         {         {
               PEG_TRACE_STRING(TRC_PROVIDERMANAGER,
             PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,                               Tracer::LEVEL2,
                 "_provider_ctrl::LOOKUP_MODULE");                 "_provider_ctrl::LOOKUP_MODULE");
               DDD(PEGASUS_STD(cout)
                   <<"--- JMPILocalProviderManager::_provider_ctrl: "
                     "LOOKUP_MODULE "
                   <<*(parms->fileName)
                   <<PEGASUS_STD(endl));
   
               AutoMutex lock (_providerTableMutex);
  
             if(false  == _modules.lookup(*(parms->fileName),             if(false  == _modules.lookup(*(parms->fileName),
                 *(reinterpret_cast<JMPIProviderModule * *>(ret))))                 *(reinterpret_cast<JMPIProviderModule * *>(ret))))
Line 214 
Line 394 
  
     case INSERT_PROVIDER:     case INSERT_PROVIDER:
         {         {
               PEG_TRACE_STRING(TRC_PROVIDERMANAGER,
             PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,                               Tracer::LEVEL2,
                 "_provider_ctrl::INSERT_PROVIDER");                 "_provider_ctrl::INSERT_PROVIDER");
             if(false  == _providers.insert(              DDD(PEGASUS_STD(cout)
                 *(parms->providerName),                  <<"--- JMPILocalProviderManager::_provider_ctrl: "
                     "INSERT_PROVIDER "
                   <<*(parms->providerName)
                   <<PEGASUS_STD(endl));
   
               AutoMutex lock (_providerTableMutex);
   
               if (false  == _providers.insert(*(parms->providerName),
                 *reinterpret_cast<JMPIProvider * *>(parm)))                 *reinterpret_cast<JMPIProvider * *>(parm)))
                 ccode = -1;                 ccode = -1;
             break;             break;
         }         }
   
     case INSERT_MODULE:     case INSERT_MODULE:
         {         {
             PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,              PEG_TRACE_STRING(TRC_PROVIDERMANAGER,
                                Tracer::LEVEL2,
                 "_provider_ctrl::INSERT_MODULE");                 "_provider_ctrl::INSERT_MODULE");
             if(false  == _modules.insert(              DDD(PEGASUS_STD(cout)
                 *(parms->fileName),                  <<"--- JMPILocalProviderManager::_provider_ctrl: "
                     "INSERT_MODULE "
                   <<*(parms->fileName)
                   <<PEGASUS_STD(endl));
   
               AutoMutex lock (_providerTableMutex);
   
               if(false  == _modules.insert(*(parms->fileName),
                 *reinterpret_cast<JMPIProviderModule * *>(parm)))                 *reinterpret_cast<JMPIProviderModule * *>(parm)))
                 ccode = -1;                 ccode = -1;
             break;             break;
         }         }
   
     case REMOVE_PROVIDER:     case REMOVE_PROVIDER:
         {         {
               PEG_TRACE_STRING(TRC_PROVIDERMANAGER,
             PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,                               Tracer::LEVEL2,
                 "_provider_ctrl::REMOVE_PROVIDER");                 "_provider_ctrl::REMOVE_PROVIDER");
               DDD(PEGASUS_STD(cout)
                   <<"--- JMPILocalProviderManager::_provider_ctrl: "
                     "REMOVE_PROVIDER "
                   <<*(parms->providerName)
                   <<PEGASUS_STD(endl));
   
               AutoMutex lock (_providerTableMutex);
   
             if(false == _providers.remove(*(parms->providerName)))             if(false == _providers.remove(*(parms->providerName)))
                 ccode = -1;                 ccode = -1;
             break;             break;
         }         }
   
     case REMOVE_MODULE:     case REMOVE_MODULE:
         {         {
               PEG_TRACE_STRING(TRC_PROVIDERMANAGER,
             PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,                               Tracer::LEVEL2,
                 "_provider_ctrl::REMOVE_MODULE");                 "_provider_ctrl::REMOVE_MODULE");
               DDD(PEGASUS_STD(cout)
                   <<"--- JMPILocalProviderManager::_provider_ctrl: REMOVE_MODULE "
                   <<*(parms->fileName)
                   <<PEGASUS_STD(endl));
   
               AutoMutex lock (_providerTableMutex);
   
             if(false == _modules.remove(*(parms->fileName)))             if(false == _modules.remove(*(parms->fileName)))
                 ccode = -1;                 ccode = -1;
             break;             break;
Line 254 
Line 467 
  
     case UNLOAD_ALL_PROVIDERS:     case UNLOAD_ALL_PROVIDERS:
         {         {
            JMPIjvm::destroyJVM();             DDD(PEGASUS_STD(cout)
                  <<"--- JMPILocalProviderManager::_provider_ctrl: "
                    "UNLOAD_ALL_PROVIDERS"
                  <<PEGASUS_STD(endl));
  
              JMPIjvm::destroyJVM();
            break;            break;
         }         }
  
     case UNLOAD_IDLE_PROVIDERS:     case UNLOAD_IDLE_PROVIDERS:
          {          {
              DDD(PEGASUS_STD(cout)
                  <<"--- JMPILocalProviderManager::_provider_ctrl: "
                    "UNLOAD_IDLE_PROVIDERS"
                  <<PEGASUS_STD(endl));
             break;             break;
         }         }
  
     case UNLOAD_IDLE_MODULES:     case UNLOAD_IDLE_MODULES:
         {         {
              DDD(PEGASUS_STD(cout)
                  <<"--- JMPILocalProviderManager::_provider_ctrl: "
                    "UNLOAD_IDLE_MODULES"
                  <<PEGASUS_STD(endl));
             break;             break;
         }         }
  
     default:     default:
           {
              DDD(PEGASUS_STD(cout)
                  <<"--- JMPILocalProviderManager::_provider_ctrl: unknown! "
                  <<code
                  <<PEGASUS_STD(endl));
         ccode = -1;         ccode = -1;
         break;         break;
     }     }
       }
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
     return(ccode);     return(ccode);
 } }
Line 287 
Line 518 
     }     }
     return NULL;     return NULL;
 } }
 /*  
 CMPIResolverModule *JMPILocalProviderManager::_loadResolver  
    (const String & fileName)  
 {  
    CMPIResolverModule *rm=new CMPIResolverModule(fileName);  
    rm->load();  
    return rm;  
 }  
 */  
 JMPIProvider::OpProviderHolder JMPILocalProviderManager::getProvider( JMPIProvider::OpProviderHolder JMPILocalProviderManager::getProvider(
     const String & fileName,     const String & fileName,
     const String & providerName,     const String & providerName,
Line 304 
Line 527 
     JMPIProvider::OpProviderHolder ph;     JMPIProvider::OpProviderHolder ph;
     CTRL_STRINGS strings;     CTRL_STRINGS strings;
     Sint32 ccode;     Sint32 ccode;
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "ProviderManager::getProvider");  
     strings.fileName = &fileName;     strings.fileName = &fileName;
     strings.providerName = &providerName;     strings.providerName = &providerName;
     strings.interfaceName = &interfaceName;     strings.interfaceName = &interfaceName;
  
       PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "ProviderManager::getProvider");
   
     try {     try {
         ccode = _provider_ctrl( GET_PROVIDER, &strings, &ph );         ccode = _provider_ctrl( GET_PROVIDER, &strings, &ph );
     }     }
     catch (Exception e) {      catch (const Exception &e) {
 #ifdef PEGASUS_DEBUG          DDD(PEGASUS_STD(cout)
        cerr<<"--- loading proxy: "<<e.getMessage()<<endl;              <<"--- JMPILocalProviderManager::getProvider: loading proxy: "
 #endif              <<e.getMessage()
               <<PEGASUS_STD(endl));
        PEG_METHOD_EXIT();        PEG_METHOD_EXIT();
         throw;         throw;
    }    }
     catch(...) {     catch(...) {
           DDD(PEGASUS_STD(cout)
               <<"--- JMPILocalProviderManager::getProvider: catch (...) "
               <<PEGASUS_STD(endl));
         PEG_METHOD_EXIT();         PEG_METHOD_EXIT();
         throw;         throw;
     }     }
  
   
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
     return(ph);     return(ph);
   
 } }
  
 void JMPILocalProviderManager::unloadProvider( void JMPILocalProviderManager::unloadProvider(
Line 344 
Line 570 
  
 void JMPILocalProviderManager::shutdownAllProviders(void) void JMPILocalProviderManager::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);
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
Line 353 
Line 578 
  
 Boolean JMPILocalProviderManager::hasActiveProviders() Boolean JMPILocalProviderManager::hasActiveProviders()
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,      PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "ProviderManager::hasActiveProviders");
         "ProviderManager::hasActiveProviders");  
       AutoMutex lock (_providerTableMutex);
   
       Boolean fRet = _providers.size() > 0;
  
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
     return (_providers.size() > 0);      return fRet;
 } }
  
 void JMPILocalProviderManager::unloadIdleProviders() void JMPILocalProviderManager::unloadIdleProviders()
Line 381 
Line 609 
             "Checking for Idle providers to unload.");             "Checking for Idle providers to unload.");
         try         try
         {         {
               AutoMutex lock(_providerTableMutex);
   
             _provider_ctrl(UNLOAD_IDLE_PROVIDERS, this, (void *)0);             _provider_ctrl(UNLOAD_IDLE_PROVIDERS, this, (void *)0);
         }         }
         catch(...)         catch(...)
Line 400 
Line 630 
  
     Array <JMPIProvider *> enableProviders;     Array <JMPIProvider *> enableProviders;
  
     Tracer::trace (TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
         "Number of providers in _providers table = %d", _providers.size ());  
   
     try     try
     {     {
         AutoMutex lock (_providerTableMutex);         AutoMutex lock (_providerTableMutex);
  
           Tracer::trace (TRC_PROVIDERMANAGER, Tracer::LEVEL4,
               "Number of providers in _providers table = %d", _providers.size ());
   
         //         //
         // Iterate through the _providers table         // Iterate through the _providers table
         //         //

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