(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.2 and 1.21

version 1.2, 2004/06/04 02:23:59 version 1.21, 2008/03/17 08:45:38
Line 1 
Line 1 
 //%/////////////////////////////////////////////////////////////////////////////  //%2006////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000 - 2003 BMC Software, Hewlett-Packard Company, IBM,  // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
 // The Open Group, Tivoli Systems  // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
   // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation, The Open Group.
   // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; Symantec Corporation; The Open Group.
 // //
 // Permission is hereby granted, free of charge, to any person obtaining a copy // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to // of this software and associated documentation files (the "Software"), to
Line 21 
Line 29 
 // //
 //============================================================================== //==============================================================================
 // //
 // Author: Chip Vincent (cvincent@us.ibm.com)  
 //  
 // Modified By: Yi Zhou, Hewlett-Packard Company(yi_zhou@hp.com)  
 //              Mike Day IBM Corporation (mdday@us.ibm.com)  
 //              Adrian Schuur, schuur@de.ibm.com  
 //  
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
   
 #include "JMPILocalProviderManager.h" #include "JMPILocalProviderManager.h"
  
   #include <Pegasus/Common/Time.h>
 #include <Pegasus/Common/Constants.h> #include <Pegasus/Common/Constants.h>
 #include <Pegasus/Common/Tracer.h> #include <Pegasus/Common/Tracer.h>
 #include <Pegasus/Common/PegasusVersion.h> #include <Pegasus/Common/PegasusVersion.h>
  
   #include <Pegasus/ProviderManager2/ProviderManager.h>
 #include <Pegasus/ProviderManager2/JMPI/JMPIProvider.h> #include <Pegasus/ProviderManager2/JMPI/JMPIProvider.h>
 #include <Pegasus/ProviderManager2/JMPI/JMPIProviderModule.h> #include <Pegasus/ProviderManager2/JMPI/JMPIProviderModule.h>
 #include <Pegasus/ProviderManager2/ProviderManagerService.h>  
  
 PEGASUS_USING_STD; PEGASUS_USING_STD;
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
 JMPILocalProviderManager::JMPILocalProviderManager(void) JMPILocalProviderManager::JMPILocalProviderManager(void)
     : _idle_timeout(IDLE_LIMIT)      : _idle_timeout(PEGASUS_PROVIDER_IDLE_TIMEOUT_SECONDS)
 { {
 } }
  
Line 54 
Line 56 
     _provider_ctrl(UNLOAD_ALL_PROVIDERS, this, &ccode);     _provider_ctrl(UNLOAD_ALL_PROVIDERS, this, &ccode);
 } }
  
 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,
            "JMPILocalProviderManager::_provider_ctrl");
  
     Sint32 ccode = 0;     Sint32 ccode = 0;
     CTRL_STRINGS *parms = reinterpret_cast<CTRL_STRINGS *>(parm);     CTRL_STRINGS *parms = reinterpret_cast<CTRL_STRINGS *>(parm);
Line 68 
Line 73 
  
     case GET_PROVIDER:     case GET_PROVIDER:
         {         {
             PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,              String providerName = *(parms->providerName);
                 "_provider_ctrl::GET_PROVIDER");              String moduleFileName = *(parms->fileName);
               String interfaceName = *(parms->interfaceName);
   
               PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL2,
                    "GET_PROVIDER providerName = %s, "
                        "moduleFileName = %s , interfaceName = %s",
                    (const char*)providerName.getCString(),
                    (const char*)moduleFileName.getCString(),
                    (const char*)interfaceName.getCString()));
   
               if (providerName.size () == 0)
               {
                  PEG_METHOD_EXIT();
                  throw NullPointer();
               }
  
             JMPIProvider *pr = NULL;  
             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
               {
                  AutoMutex lock (_providerTableMutex);
  
             if(true == _providers.lookup( *(parms->providerName), pr ))                 if (true == _providers.lookup(providerName, provider))
             {             {
                 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,                     PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
                     "Found JMPIProvider " + *(parms->providerName) + " in JMPIProvider Manager Cache");                          "Found JMPIProvider %s in JMPIProvider Manager Cache",
                           (const char*)providerName.getCString()));
                      PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
                           "SetProvider(%X) at provider holder.",
                           (long)provider));
   
                      ph->SetProvider(provider);
  
                 ph->SetProvider( pr );  ///////////////////ph->GetProvider().update_idle_timer();
 //                ph->GetProvider().update_idle_timer();  
                 break;                 break;
             }             }
  
                  PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL2,
                       "Creating JMPIProvider %s",
                       (const char*)providerName.getCString()));
  
             PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,                 if (false == _modules.lookup(moduleFileName, module))
                 "Creating JMPIProvider " + *(parms->providerName) );                 {
             JMPIProviderModule *module;                     PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
                           "Creating JMPIProvider Module %s",
                           (const char*)moduleFileName.getCString()));
  
             if(false  == _modules.lookup(*(parms->fileName), module))                     newModule = new JMPIProviderModule(moduleFileName,
                                                         interfaceName);
                      if (0 == newModule)
             {             {
                 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,                         PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER,Tracer::LEVEL2,
                     "Creating JMPIProvider Module " + *(parms->fileName) );                              "New JMPIProviderModule is NULL!");
                          PEG_METHOD_EXIT();
                          throw NullPointer();
                      }
  
                 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((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
                     "Using Cached  JMPIProvider Module " + *(parms->fileName) );                          "Using Cached JMPIProvider Module %s",
                           (const char*)moduleFileName.getCString()));
             }             }
  
                  PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
                       "Loading/Linking JMPIProvider Module %s",
                       (const char*)moduleFileName.getCString()));
  
             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((TRC_PROVIDERMANAGER,Tracer::LEVEL2,
                     "Exception caught Loading/Linking JMPIProvider Module " + *(parms->fileName) );                                      "Exception caught Loading/Linking"
                               "JMPIProvider Module %s",
                           (const char*)moduleFileName.getCString()));
                      PEG_METHOD_EXIT();
                 throw;                 throw;
             }             }
  
             // create provider module             // create provider module
                  newProvider = new JMPIProvider(providerName, module, &base);
                  if (0 == newProvider)
                  {
                      PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER,Tracer::LEVEL2,
                                       "New JMPIProvider is NULL!");
                      PEG_METHOD_EXIT();
                      throw NullPointer();
                  }
   
                  provider = newProvider;
  
             MessageQueue * queue = MessageQueue::lookup(PEGASUS_QUEUENAME_PROVIDERMANAGER_CPP);                 if (0 == (provider->_cimom_handle = new CIMOMHandle()))
             PEGASUS_ASSERT(queue != 0);                 {
             MessageQueueService * service = dynamic_cast<MessageQueueService *>(queue);                     PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER,Tracer::LEVEL2,
             PEGASUS_ASSERT(service != 0);                                      "CIMOMhandle is NULL!");
             pr = new JMPIProvider(*(parms->providerName), module, &base);                     PEG_METHOD_EXIT();
             if(0 == (pr->_cimom_handle =  new CIMOMHandle()))  
                 throw NullPointer();                 throw NullPointer();
             pr->_quantum=0;                 }
  
                  provider->_quantum = 0;
  
             PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,                 {
                 "Loading JMPIProvider " +  pr->_name);                    AutoMutex lock(provider->_statusMutex);
   
                     PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL2,
                          "Loading JMPIProvider %s",
                          (const char*)provider->_name.getCString()));
             try             try
             {             {
                 pr->initialize(*(pr->_cimom_handle));                        provider->initialize(*(provider->_cimom_handle));
                     }
                     catch(CIMException &cimExcept)
                     {
                         PEG_TRACE((TRC_DISCARDED_DATA,Tracer::LEVEL2,
                             "Calling provider->initialize caused exception: %s",
                             (const char*)cimExcept.getMessage().getCString()));
   
                         throw;
                     }
                     catch(Exception &except)
                     {
                         PEG_TRACE((TRC_DISCARDED_DATA,Tracer::LEVEL2,
                             "Calling provider->initialize caused exception: %s",
                             (const char*)except.getMessage().getCString()));
   
                         throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
                                                     except.getMessage());
             }             }
             catch(...)             catch(...)
             {             {
                 delete pr->_cimom_handle;                        PEG_TRACE_CSTRING(TRC_DISCARDED_DATA,Tracer::LEVEL2,
                 delete pr;                                         "Exception caught calling initialize!");
   
                 throw UninitializedObjectException();                 throw UninitializedObjectException();
             }             }
                  }
   
   ///////////////provider->update_idle_timer();
   
                  _providers.insert(providerName, provider);
               }
               catch (...)
               {
                  if (newModule)
                  {
                     _modules.remove(moduleFileName);
                  }
  
 //            pr->update_idle_timer();                 delete newModule;
  
             _providers.insert(*(parms->providerName), pr);                 if (newProvider)
                  {
                     delete newProvider->_cimom_handle;
                  }
  
                  delete newProvider;
                  PEG_METHOD_EXIT();
                  throw;
               }
  
             ph->SetProvider( pr );              PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
                    "SetProvider(%X) at provider holder.",
                    (long)provider));
   
               ph->SetProvider( provider );
             break;             break;
         }         }
  
     case UNLOAD_PROVIDER:     case UNLOAD_PROVIDER:
         {         {
               PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER,Tracer::LEVEL2,
                   "UNLOAD_PROVIDER");
             break;             break;
         }         }
  
     case LOOKUP_PROVIDER:     case LOOKUP_PROVIDER:
         {         {
               PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL2,
                    "LOOKUP_PROVIDER providerName = %s ",
                    (const char*)*(parms->providerName)->getCString()));
  
             PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,              AutoMutex lock (_providerTableMutex);
                 "_provider_ctrl::LOOKUP_PROVIDER");  
  
             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((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
                     "Found JMPIProvider in cache: " +                       "Found JMPIProvider %s in JMPIProvider Manager Cache",
                     *(parms->providerName));                       (const char*)*(parms->providerName)->getCString()));
   
 //                (*(reinterpret_cast<JMPIProvider * *>(ret)))->update_idle_timer();  
             }             }
             else             else
             {             {
                   PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
                 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,                       "Could not find JMPIProvider %s in "
                     "Could not find  JMPIProvider in cache: " +                           "JMPIProvider Manager Cache",
                     *(parms->providerName));                       (const char*)*(parms->providerName)->getCString()));
                 ccode = -1;                 ccode = -1;
             }             }
  
Line 190 
Line 291 
  
     case LOOKUP_MODULE:     case LOOKUP_MODULE:
         {         {
               PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL2,
                    "LOOKUP_MODULE moduleName = %s ",
                    (const char*)*(parms->fileName)->getCString()));
  
             PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,              AutoMutex lock (_providerTableMutex);
                 "_provider_ctrl::LOOKUP_MODULE");  
  
             if(false  == _modules.lookup(*(parms->fileName),             if(false  == _modules.lookup(*(parms->fileName),
                 *(reinterpret_cast<JMPIProviderModule * *>(ret))))                 *(reinterpret_cast<JMPIProviderModule * *>(ret))))
             {             {
                 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,                  PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
                     "Could not find  JMPIProvider Module in cache: " +                       "Could not find JMPIProvider Module %s in "
                     *(parms->fileName));                           "JMPIProvider Manager Cache",
                        (const char*)*(parms->fileName)->getCString()));
                 ccode = -1;                 ccode = -1;
             }             }
  
Line 208 
Line 312 
  
     case INSERT_PROVIDER:     case INSERT_PROVIDER:
         {         {
               PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL2,
                    "INSERT_PROVIDER providerName = %s ",
                    (const char*)*(parms->providerName)->getCString()));
   
               AutoMutex lock (_providerTableMutex);
  
             PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,              if (false  == _providers.insert(*(parms->providerName),
                 "_provider_ctrl::INSERT_PROVIDER");  
             if(false  == _providers.insert(  
                 *(parms->providerName),  
                 *reinterpret_cast<JMPIProvider * *>(parm)))                 *reinterpret_cast<JMPIProvider * *>(parm)))
               {
                   PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
                        "Can not insert JMPIProvider %s into "
                            "JMPIProvider Manager Cache",
                        (const char*)*(parms->providerName)->getCString()));
                 ccode = -1;                 ccode = -1;
               }
             break;             break;
         }         }
   
     case INSERT_MODULE:     case INSERT_MODULE:
         {         {
             PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,              PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL2,
                 "_provider_ctrl::INSERT_MODULE");                   "INSERT_MODULE moduleName = %s ",
             if(false  == _modules.insert(                   (const char*)*(parms->fileName)->getCString()));
                 *(parms->fileName),  
               AutoMutex lock (_providerTableMutex);
   
               if(false  == _modules.insert(*(parms->fileName),
                 *reinterpret_cast<JMPIProviderModule * *>(parm)))                 *reinterpret_cast<JMPIProviderModule * *>(parm)))
               {
                   PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
                        "Can not insert JMPIProvider Module %s into "
                            "JMPIProvider Manager Cache",
                        (const char*)*(parms->fileName)->getCString()));
                 ccode = -1;                 ccode = -1;
               }
             break;             break;
         }         }
   
     case REMOVE_PROVIDER:     case REMOVE_PROVIDER:
         {         {
               PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL2,
                    "REMOVE_PROVIDER providerName = %s ",
                    (const char*)*(parms->providerName)->getCString()));
   
               AutoMutex lock (_providerTableMutex);
  
             PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,  
                 "_provider_ctrl::REMOVE_PROVIDER");  
             if(false == _providers.remove(*(parms->providerName)))             if(false == _providers.remove(*(parms->providerName)))
               {
                   PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
                        "Can not remove JMPIProvider %s from "
                            "JMPIProvider Manager Cache",
                        (const char*)*(parms->providerName)->getCString()));
                 ccode = -1;                 ccode = -1;
               }
   
             break;             break;
         }         }
   
     case REMOVE_MODULE:     case REMOVE_MODULE:
         {         {
               PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL2,
                    "REMOVE_MODULE moduleName = %s ",
                    (const char*)*(parms->fileName)->getCString()));
   
               AutoMutex lock (_providerTableMutex);
  
             PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,  
                 "_provider_ctrl::REMOVE_MODULE");  
             if(false == _modules.remove(*(parms->fileName)))             if(false == _modules.remove(*(parms->fileName)))
               {
                   PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
                        "Can not remove JMPIProvider Module %s from "
                            "JMPIProvider Manager Cache",
                        (const char*)*(parms->fileName)->getCString()));
                 ccode = -1;                 ccode = -1;
               }
             break;             break;
         }         }
  
     case UNLOAD_ALL_PROVIDERS:     case UNLOAD_ALL_PROVIDERS:
         {         {
               PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER,Tracer::LEVEL2,
                   "UNLOAD_ALL_PROVIDERS");
              JMPIjvm::destroyJVM();
             break;             break;
         }         }
  
     case UNLOAD_IDLE_PROVIDERS:     case UNLOAD_IDLE_PROVIDERS:
          {          {
              PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER,Tracer::LEVEL2,
                  "UNLOAD_IDLE_PROVIDERS");
             break;             break;
         }         }
  
     case UNLOAD_IDLE_MODULES:     case UNLOAD_IDLE_MODULES:
         {         {
               PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER,Tracer::LEVEL2,
                   "UNLOAD_IDLE_MODULES");
             break;             break;
         }         }
  
     default:     default:
           {
               PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL2,
                    "Provider Control: Unknown function code %d.",
                    code));
         ccode = -1;         ccode = -1;
         break;         break;
     }     }
       }
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
     return(ccode);     return(ccode);
 } }
Line 279 
Line 434 
     }     }
     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 296 
Line 443 
     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)
        std::cerr<<"--- loading proxy: "<<e.getMessage()<<std::endl;      {
           PEG_TRACE((TRC_DISCARDED_DATA,Tracer::LEVEL2,
                "Can not get provider. Caught exception: %s",
               (const char*)e.getMessage().getCString()));
        PEG_METHOD_EXIT();        PEG_METHOD_EXIT();
         throw;         throw;
    }    }
     catch(...) {     catch(...) {
           PEG_TRACE_CSTRING(TRC_DISCARDED_DATA,Tracer::LEVEL2,
                "Can not get provider. Caught unknown exception,");
         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 334 
Line 485 
  
 void JMPILocalProviderManager::shutdownAllProviders(void) void JMPILocalProviderManager::shutdownAllProviders(void)
 { {
       PEG_METHOD_ENTER(
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "ProviderManager::shutdownAllProviders");          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 343 
Line 495 
  
 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 355 
Line 512 
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
         "ProviderManager::unloadIdleProviders");         "ProviderManager::unloadIdleProviders");
  
     static struct timeval first = {0,0}, now, last = {0,0};      try
       {
           AutoMutex lock(_providerTableMutex);
  
     if(first.tv_sec == 0)          _provider_ctrl(UNLOAD_IDLE_PROVIDERS, this, (void *)0);
       }
       catch(...)
     {     {
         gettimeofday(&first, NULL);          PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
               "Caught unexpected exception from UNLOAD_IDLE_PROVIDERS.");
       }
   
       PEG_METHOD_EXIT();
     }     }
     gettimeofday(&now, NULL);  
  
     if (((now.tv_sec - first.tv_sec) > IDLE_LIMIT) &&  Array <JMPIProvider *>
        ((now.tv_sec - last.tv_sec) > IDLE_LIMIT))  JMPILocalProviderManager::getIndicationProvidersToEnable ()
     {     {
         gettimeofday(&last, NULL);      PEG_METHOD_ENTER (TRC_PROVIDERMANAGER,
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,          "JMPILocalProviderManager::getIndicationProvidersToEnable");
             "Checking for Idle providers to unload.");  
       Array <JMPIProvider *> enableProviders;
   
         try         try
         {         {
             _provider_ctrl(UNLOAD_IDLE_PROVIDERS, this, (void *)0);          AutoMutex lock (_providerTableMutex);
   
           PEG_TRACE((
               TRC_PROVIDERMANAGER,
               Tracer::LEVEL4,
               "Number of providers in _providers table = %d",
               _providers.size ()));
   
           //
           // Iterate through the _providers table
           //
           for (ProviderTable::Iterator i = _providers.start (); i != 0; i++)
           {
               //
               //  Enable any indication provider with current subscriptions
               //
               JMPIProvider * provider = i.value ();
               if (provider->testSubscriptions ())
               {
                   enableProviders.append (provider);
         }         }
         catch(...)          }
       }
       catch (CIMException & e)
         {         {
             PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,          PEG_TRACE_STRING (TRC_DISCARDED_DATA, Tracer::LEVEL2,
                 "Caught unexpected exception from UNLOAD_IDLE_PROVIDERS.");              "CIMException: " + e.getMessage ());
         }         }
       catch (Exception & e)
       {
           PEG_TRACE_STRING (TRC_DISCARDED_DATA, Tracer::LEVEL2,
               "Exception: " + e.getMessage ());
       }
       catch (...)
       {
           PEG_TRACE_CSTRING (TRC_DISCARDED_DATA, Tracer::LEVEL2,
               "Unexpected error in getIndicationProvidersToEnable");
     }     }
   
       PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
           "Number of indication providers to enable = %d",
           enableProviders.size ()));
   
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
       return enableProviders;
 } }
  
   
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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