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

version 1.9.8.1, 2006/02/10 16:12:03 version 1.21, 2008/03/17 08:45:38
Line 29 
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
  
 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(PEGASUS_PROVIDER_IDLE_TIMEOUT_SECONDS)
 { {
 #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 78 
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 91 
Line 73 
  
     case GET_PROVIDER:     case GET_PROVIDER:
         {         {
             PEG_TRACE_STRING(TRC_PROVIDERMANAGER,  
                              Tracer::LEVEL2,  
                              "_provider_ctrl::GET_PROVIDER");  
   
             String providerName = *(parms->providerName);             String providerName = *(parms->providerName);
             String moduleFileName = *(parms->fileName);             String moduleFileName = *(parms->fileName);
             String interfaceName = *(parms->interfaceName);             String interfaceName = *(parms->interfaceName);
  
             DDD(PEGASUS_STD(cout)              PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL2,
                 <<"--- JMPILocalProviderManager::_provider_ctrl: GET_PROVIDER "                   "GET_PROVIDER providerName = %s, "
                 <<providerName                       "moduleFileName = %s , interfaceName = %s",
                 <<PEGASUS_STD(endl));                   (const char*)providerName.getCString(),
                    (const char*)moduleFileName.getCString(),
                    (const char*)interfaceName.getCString()));
   
               if (providerName.size () == 0)
               {
                  PEG_METHOD_EXIT();
                  throw NullPointer();
               }
  
             JMPIProvider::OpProviderHolder* ph =             JMPIProvider::OpProviderHolder* ph =
                reinterpret_cast< JMPIProvider::OpProviderHolder* >( ret );                reinterpret_cast< JMPIProvider::OpProviderHolder* >( ret );
Line 114 
Line 100 
  
             try             try
             {             {
                {  
                   AutoMutex lock (_providerTableMutex);                   AutoMutex lock (_providerTableMutex);
  
                   if (true == _providers.lookup(providerName, provider))                   if (true == _providers.lookup(providerName, provider))
                   {                   {
                       PEG_TRACE_STRING(TRC_PROVIDERMANAGER,                     PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
                                        Tracer::LEVEL4,                          "Found JMPIProvider %s in JMPIProvider Manager Cache",
                                        "Found JMPIProvider "                          (const char*)providerName.getCString()));
                                        + providerName                     PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
                                        + " in JMPIProvider Manager Cache");                          "SetProvider(%X) at provider holder.",
                       DDD(PEGASUS_STD(cout)                          (long)provider));
                           <<"--- 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->SetProvider(provider);
  
 //////////////////////ph->GetProvider().update_idle_timer();  ///////////////////ph->GetProvider().update_idle_timer();
                       break;                       break;
                   }                   }
  
                   PEG_TRACE_STRING(TRC_PROVIDERMANAGER,                 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL2,
                                    Tracer::LEVEL4,                      "Creating JMPIProvider %s",
                                    "Creating JMPIProvider " + providerName );                      (const char*)providerName.getCString()));
                   DDD(PEGASUS_STD(cout)  
                       <<"--- JMPILocalProviderManager::_provider_ctrl: Creating "  
                       <<providerName  
                       <<PEGASUS_STD(endl));  
  
                   if (false == _modules.lookup(moduleFileName, module))                   if (false == _modules.lookup(moduleFileName, module))
                   {                   {
                       PEG_TRACE_STRING(TRC_PROVIDERMANAGER,                     PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
                                        Tracer::LEVEL4,                          "Creating JMPIProvider Module %s",
                                        "Creating JMPIProvider Module "                          (const char*)moduleFileName.getCString()));
                                        + moduleFileName );  
                       DDD(PEGASUS_STD(cout)  
                           <<"--- JMPILocalProviderManager::_provider_ctrl: "  
                             "Creating module "  
                             <<moduleFileName  
                             <<PEGASUS_STD(endl));  
  
                       newModule = new JMPIProviderModule(moduleFileName,                       newModule = new JMPIProviderModule(moduleFileName,
                                                          interfaceName);                                                          interfaceName);
   
                       if (0 == newModule)                       if (0 == newModule)
                       {                       {
                           PEG_TRACE_STRING(TRC_PROVIDERMANAGER,                         PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER,Tracer::LEVEL2,
                                            Tracer::LEVEL4,                              "New JMPIProviderModule is NULL!");
                                            "new JMPIProviderModule is NULL!");                         PEG_METHOD_EXIT();
                           DDD(PEGASUS_STD(cout)  
                               <<"--- JMPILocalProviderManager::_provider_ctrl:"  
                                 " new JMPIProviderModule is NULL!"  
                                 <<PEGASUS_STD(endl));  
   
                           throw NullPointer();                           throw NullPointer();
                       }                       }
  
Line 185 
Line 143 
                   }                   }
                   else                   else
                   {                   {
                       PEG_TRACE_STRING(TRC_PROVIDERMANAGER,                     PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
                                        Tracer::LEVEL4,                          "Using Cached JMPIProvider Module %s",
                                        "Using Cached JMPIProvider Module "                          (const char*)moduleFileName.getCString()));
                                        + moduleFileName);  
                       DDD(PEGASUS_STD(cout)  
                           <<"--- JMPILocalProviderManager::_provider_ctrl: "  
                           "Using cached "  
                           <<moduleFileName  
                           <<PEGASUS_STD(endl));  
                   }  
                }                }
  
                PEG_TRACE_STRING(TRC_PROVIDERMANAGER,                 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
                                 Tracer::LEVEL4,                      "Loading/Linking JMPIProvider Module %s",
                                 "Loading/Linking JMPIProvider Module "                      (const char*)moduleFileName.getCString()));
                                 + moduleFileName );  
                DDD(PEGASUS_STD(cout)  
                    <<"--- JMPILocalProviderManager::_provider_ctrl:"  
                      " Loading/Linking module "  
                      <<moduleFileName  
                      <<PEGASUS_STD(endl));  
  
                try                try
                {                {
Line 213 
Line 158 
                }                }
                catch(...)                catch(...)
                {                {
                    PEG_TRACE_STRING(TRC_PROVIDERMANAGER,                     PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL2,
                                     Tracer::LEVEL4,  
                                     "Exception caught Loading/Linking"                                     "Exception caught Loading/Linking"
                                     " JMPIProvider Module "                              "JMPIProvider Module %s",
                                     + moduleFileName );                          (const char*)moduleFileName.getCString()));
                    DDD(PEGASUS_STD(cout)                     PEG_METHOD_EXIT();
                        <<"--- JMPILocalProviderManager::_provider_ctrl: "  
                        "Exception caught Loading/Linking module "  
                        <<moduleFileName  
                        <<PEGASUS_STD(endl));  
   
                    throw;                    throw;
                }                }
  
Line 231 
Line 170 
                newProvider = new JMPIProvider(providerName, module, &base);                newProvider = new JMPIProvider(providerName, module, &base);
                if (0 == newProvider)                if (0 == newProvider)
                {                {
                    PEG_TRACE_STRING(TRC_PROVIDERMANAGER,                     PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER,Tracer::LEVEL2,
                                     Tracer::LEVEL4,                                      "New JMPIProvider is NULL!");
                                     "new JMPIProvider is NULL!");                     PEG_METHOD_EXIT();
                    DDD(PEGASUS_STD(cout)  
                        <<"--- JMPILocalProviderManager::_provider_ctrl: "  
                          "new JMPIProvider is NULL!"  
                        <<PEGASUS_STD(endl));  
   
                    throw NullPointer();                    throw NullPointer();
                }                }
  
Line 246 
Line 180 
  
                if (0 == (provider->_cimom_handle = new CIMOMHandle()))                if (0 == (provider->_cimom_handle = new CIMOMHandle()))
                {                {
                    PEG_TRACE_STRING(TRC_PROVIDERMANAGER,                     PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER,Tracer::LEVEL2,
                                     Tracer::LEVEL4,                                      "CIMOMhandle is NULL!");
                                     "_cimom_handle is NULL!");                     PEG_METHOD_EXIT();
                    DDD(PEGASUS_STD(cout)  
                        <<"--- JMPILocalProviderManager::_provider_ctrl:"  
                          " _cimom_handle is NULL!"  
                          <<PEGASUS_STD(endl));  
   
                    throw NullPointer();                    throw NullPointer();
                }                }
  
Line 262 
Line 191 
                {                {
                   AutoMutex lock(provider->_statusMutex);                   AutoMutex lock(provider->_statusMutex);
  
                   PEG_TRACE_STRING(TRC_PROVIDERMANAGER,                    PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL2,
                                    Tracer::LEVEL2,                         "Loading JMPIProvider %s",
                                    "Loading JMPIProvider "                         (const char*)provider->_name.getCString()));
                                    +  provider->_name);  
                   DDD(PEGASUS_STD(cout)  
                       <<"--- JMPILocalProviderManager::_provider_ctrl:"  
                         " Loading "  
                         <<provider->_name  
                         <<PEGASUS_STD(endl));  
                   try                   try
                   {                   {
                       provider->initialize(*(provider->_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(...)
                   {                   {
                       PEG_TRACE_STRING(TRC_PROVIDERMANAGER,                        PEG_TRACE_CSTRING(TRC_DISCARDED_DATA,Tracer::LEVEL2,
                                        Tracer::LEVEL4,  
                                        "Exception caught calling initialize!");                                        "Exception caught calling initialize!");
                       DDD(PEGASUS_STD(cout)  
                           <<"--- JMPILocalProviderManager::_provider_ctrl:"  
                             " Exception caught calling initialize!"  
                             <<PEGASUS_STD(endl));  
  
                       throw UninitializedObjectException();                       throw UninitializedObjectException();
                   }                   }
                }                }
   
   ///////////////provider->update_idle_timer();
   
                  _providers.insert(providerName, provider);
             }             }
             catch (...)             catch (...)
             {             {
Line 304 
Line 243 
                }                }
  
                delete newProvider;                delete newProvider;
                  PEG_METHOD_EXIT();
                throw;                throw;
             }             }
  
               PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
 //          provider->update_idle_timer();                   "SetProvider(%X) at provider holder.",
                    (long)provider));
             _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 );             ph->SetProvider( provider );
             break;             break;
Line 327 
Line 257 
  
     case UNLOAD_PROVIDER:     case UNLOAD_PROVIDER:
         {         {
             DDD(PEGASUS_STD(cout)              PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER,Tracer::LEVEL2,
                 <<"--- JMPILocalProviderManager::_provider_ctrl: "                  "UNLOAD_PROVIDER");
                   "UNLOAD_PROVIDER"  
                   <<PEGASUS_STD(endl));  
             break;             break;
         }         }
  
     case LOOKUP_PROVIDER:     case LOOKUP_PROVIDER:
         {         {
             PEG_TRACE_STRING(TRC_PROVIDERMANAGER,              PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL2,
                              Tracer::LEVEL2,                   "LOOKUP_PROVIDER providerName = %s ",
                              "_provider_ctrl::LOOKUP_PROVIDER");                   (const char*)*(parms->providerName)->getCString()));
             DDD(PEGASUS_STD(cout)  
                 <<"--- JMPILocalProviderManager::_provider_ctrl: "  
                 "LOOKUP_PROVIDER "  
                 <<*(parms->providerName)  
                 <<PEGASUS_STD(endl));  
  
             AutoMutex lock (_providerTableMutex);             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,                  PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
                                  Tracer::LEVEL4,                       "Found JMPIProvider %s in JMPIProvider Manager Cache",
                                  "Found JMPIProvider in cache: "                       (const char*)*(parms->providerName)->getCString()));
                                  + *(parms->providerName));  
   
 ////////////////(*(reinterpret_cast<JMPIProvider * *>(ret)))->update_idle_timer();  
             }             }
             else             else
             {             {
                 PEG_TRACE_STRING(TRC_PROVIDERMANAGER,                  PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
                                  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 371 
Line 291 
  
     case LOOKUP_MODULE:     case LOOKUP_MODULE:
         {         {
             PEG_TRACE_STRING(TRC_PROVIDERMANAGER,              PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL2,
                              Tracer::LEVEL2,                   "LOOKUP_MODULE moduleName = %s ",
                              "_provider_ctrl::LOOKUP_MODULE");                   (const char*)*(parms->fileName)->getCString()));
             DDD(PEGASUS_STD(cout)  
                 <<"--- JMPILocalProviderManager::_provider_ctrl: "  
                   "LOOKUP_MODULE "  
                 <<*(parms->fileName)  
                 <<PEGASUS_STD(endl));  
  
             AutoMutex lock (_providerTableMutex);             AutoMutex lock (_providerTableMutex);
  
             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 396 
Line 312 
  
     case INSERT_PROVIDER:     case INSERT_PROVIDER:
         {         {
             PEG_TRACE_STRING(TRC_PROVIDERMANAGER,              PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL2,
                              Tracer::LEVEL2,                   "INSERT_PROVIDER providerName = %s ",
                              "_provider_ctrl::INSERT_PROVIDER");                   (const char*)*(parms->providerName)->getCString()));
             DDD(PEGASUS_STD(cout)  
                 <<"--- JMPILocalProviderManager::_provider_ctrl: "  
                   "INSERT_PROVIDER "  
                 <<*(parms->providerName)  
                 <<PEGASUS_STD(endl));  
  
             AutoMutex lock (_providerTableMutex);             AutoMutex lock (_providerTableMutex);
  
             if (false  == _providers.insert(*(parms->providerName),             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,              PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL2,
                              Tracer::LEVEL2,                   "INSERT_MODULE moduleName = %s ",
                              "_provider_ctrl::INSERT_MODULE");                   (const char*)*(parms->fileName)->getCString()));
             DDD(PEGASUS_STD(cout)  
                 <<"--- JMPILocalProviderManager::_provider_ctrl: "  
                   "INSERT_MODULE "  
                 <<*(parms->fileName)  
                 <<PEGASUS_STD(endl));  
  
             AutoMutex lock (_providerTableMutex);             AutoMutex lock (_providerTableMutex);
  
             if(false  == _modules.insert(*(parms->fileName),             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_STRING(TRC_PROVIDERMANAGER,              PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL2,
                              Tracer::LEVEL2,                   "REMOVE_PROVIDER providerName = %s ",
                              "_provider_ctrl::REMOVE_PROVIDER");                   (const char*)*(parms->providerName)->getCString()));
             DDD(PEGASUS_STD(cout)  
                 <<"--- JMPILocalProviderManager::_provider_ctrl: "  
                   "REMOVE_PROVIDER "  
                 <<*(parms->providerName)  
                 <<PEGASUS_STD(endl));  
  
             AutoMutex lock (_providerTableMutex);             AutoMutex lock (_providerTableMutex);
  
             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_STRING(TRC_PROVIDERMANAGER,              PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL2,
                              Tracer::LEVEL2,                   "REMOVE_MODULE moduleName = %s ",
                              "_provider_ctrl::REMOVE_MODULE");                   (const char*)*(parms->fileName)->getCString()));
             DDD(PEGASUS_STD(cout)  
                 <<"--- JMPILocalProviderManager::_provider_ctrl: REMOVE_MODULE "  
                 <<*(parms->fileName)  
                 <<PEGASUS_STD(endl));  
  
             AutoMutex lock (_providerTableMutex);             AutoMutex lock (_providerTableMutex);
  
             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:
         {         {
            DDD(PEGASUS_STD(cout)              PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER,Tracer::LEVEL2,
                <<"--- JMPILocalProviderManager::_provider_ctrl: "                  "UNLOAD_ALL_PROVIDERS");
                  "UNLOAD_ALL_PROVIDERS"  
                <<PEGASUS_STD(endl));  
   
            JMPIjvm::destroyJVM();            JMPIjvm::destroyJVM();
            break;            break;
         }         }
  
     case UNLOAD_IDLE_PROVIDERS:     case UNLOAD_IDLE_PROVIDERS:
          {          {
            DDD(PEGASUS_STD(cout)             PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER,Tracer::LEVEL2,
                <<"--- JMPILocalProviderManager::_provider_ctrl: "                 "UNLOAD_IDLE_PROVIDERS");
                  "UNLOAD_IDLE_PROVIDERS"  
                <<PEGASUS_STD(endl));  
            break;            break;
         }         }
  
     case UNLOAD_IDLE_MODULES:     case UNLOAD_IDLE_MODULES:
         {         {
            DDD(PEGASUS_STD(cout)              PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER,Tracer::LEVEL2,
                <<"--- JMPILocalProviderManager::_provider_ctrl: "                  "UNLOAD_IDLE_MODULES");
                  "UNLOAD_IDLE_MODULES"  
                <<PEGASUS_STD(endl));  
            break;            break;
         }         }
  
     default:     default:
         {         {
            DDD(PEGASUS_STD(cout)              PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL2,
                <<"--- JMPILocalProviderManager::_provider_ctrl: unknown! "                   "Provider Control: Unknown function code %d.",
                <<code                   code));
                <<PEGASUS_STD(endl));  
            ccode = -1;            ccode = -1;
            break;            break;
         }         }
Line 538 
Line 452 
     try {     try {
         ccode = _provider_ctrl( GET_PROVIDER, &strings, &ph );         ccode = _provider_ctrl( GET_PROVIDER, &strings, &ph );
     }     }
     catch (const Exception &e) {      catch (const Exception &e)
         DDD(PEGASUS_STD(cout)      {
             <<"--- JMPILocalProviderManager::getProvider: loading proxy: "          PEG_TRACE((TRC_DISCARDED_DATA,Tracer::LEVEL2,
             <<e.getMessage()               "Can not get provider. Caught exception: %s",
             <<PEGASUS_STD(endl));              (const char*)e.getMessage().getCString()));
         PEG_METHOD_EXIT();         PEG_METHOD_EXIT();
         throw;         throw;
     }     }
     catch(...) {     catch(...) {
         DDD(PEGASUS_STD(cout)          PEG_TRACE_CSTRING(TRC_DISCARDED_DATA,Tracer::LEVEL2,
             <<"--- JMPILocalProviderManager::getProvider: catch (...) "               "Can not get provider. Caught unknown exception,");
             <<PEGASUS_STD(endl));  
         PEG_METHOD_EXIT();         PEG_METHOD_EXIT();
         throw;         throw;
     }     }
Line 572 
Line 485 
  
 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 580 
Line 495 
  
 Boolean JMPILocalProviderManager::hasActiveProviders() Boolean JMPILocalProviderManager::hasActiveProviders()
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "ProviderManager::hasActiveProviders");      PEG_METHOD_ENTER(
           TRC_PROVIDERMANAGER,
           "ProviderManager::hasActiveProviders");
  
     AutoMutex lock (_providerTableMutex);     AutoMutex lock (_providerTableMutex);
  
Line 595 
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};  
   
     if(first.tv_sec == 0)  
     {  
         gettimeofday(&first, NULL);  
     }  
     gettimeofday(&now, NULL);  
   
     if (((now.tv_sec - first.tv_sec) > IDLE_LIMIT) &&  
        ((now.tv_sec - last.tv_sec) > IDLE_LIMIT))  
     {  
         gettimeofday(&last, NULL);  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Checking for Idle providers to unload.");  
         try         try
         {         {
             AutoMutex lock(_providerTableMutex);             AutoMutex lock(_providerTableMutex);
Line 617 
Line 520 
         }         }
         catch(...)         catch(...)
         {         {
             PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,          PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
                 "Caught unexpected exception from UNLOAD_IDLE_PROVIDERS.");                 "Caught unexpected exception from UNLOAD_IDLE_PROVIDERS.");
         }         }
     }  
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
 } }
  
Line 636 
Line 539 
     {     {
         AutoMutex lock (_providerTableMutex);         AutoMutex lock (_providerTableMutex);
  
         Tracer::trace (TRC_PROVIDERMANAGER, Tracer::LEVEL4,          PEG_TRACE((
             "Number of providers in _providers table = %d", _providers.size ());              TRC_PROVIDERMANAGER,
               Tracer::LEVEL4,
               "Number of providers in _providers table = %d",
               _providers.size ()));
  
         //         //
         // Iterate through the _providers table         // Iterate through the _providers table
Line 666 
Line 572 
     }     }
     catch (...)     catch (...)
     {     {
         PEG_TRACE_STRING (TRC_DISCARDED_DATA, Tracer::LEVEL2,          PEG_TRACE_CSTRING (TRC_DISCARDED_DATA, Tracer::LEVEL2,
             "Unexpected error in getIndicationProvidersToEnable");             "Unexpected error in getIndicationProvidersToEnable");
     }     }
  
     Tracer::trace (TRC_PROVIDERMANAGER, Tracer::LEVEL4,      PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
         "Number of indication providers to enable = %d",         "Number of indication providers to enable = %d",
         enableProviders.size ());          enableProviders.size ()));
  
     PEG_METHOD_EXIT ();     PEG_METHOD_EXIT ();
     return enableProviders;     return enableProviders;

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