version 1.8, 2005/02/25 21:44:19
|
version 1.21, 2008/03/17 08:45:38
|
|
|
//%2005//////////////////////////////////////////////////////////////////////// |
//%2006//////////////////////////////////////////////////////////////////////// |
// | // |
// Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development | // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development |
// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems. | // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems. |
|
|
// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group. | // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group. |
// Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.; | // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.; |
// EMC Corporation; VERITAS Software Corporation; The Open Group. | // 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 |
|
|
// | // |
//============================================================================== | //============================================================================== |
// | // |
// 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) |
{ | { |
} | } |
| |
|
|
_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); |
|
|
| |
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( pr ); |
ph->SetProvider(provider); |
// 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(); |
} | } |
|
} |
| |
// pr->update_idle_timer(); |
///////////////provider->update_idle_timer(); |
| |
_providers.insert(*(parms->providerName), pr); |
_providers.insert(providerName, provider); |
|
} |
|
catch (...) |
|
{ |
|
if (newModule) |
|
{ |
|
_modules.remove(moduleFileName); |
|
} |
|
|
|
delete newModule; |
|
|
|
if (newProvider) |
|
{ |
|
delete newProvider->_cimom_handle; |
|
} |
|
|
|
delete newProvider; |
|
PEG_METHOD_EXIT(); |
|
throw; |
|
} |
| |
|
PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4, |
|
"SetProvider(%X) at provider holder.", |
|
(long)provider)); |
| |
ph->SetProvider( pr ); |
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; |
} | } |
| |
|
|
| |
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; |
} | } |
| |
|
|
| |
case INSERT_PROVIDER: | case INSERT_PROVIDER: |
{ | { |
|
PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL2, |
|
"INSERT_PROVIDER providerName = %s ", |
|
(const char*)*(parms->providerName)->getCString())); |
| |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
AutoMutex lock (_providerTableMutex); |
"_provider_ctrl::INSERT_PROVIDER"); |
|
if(false == _providers.insert( |
if (false == _providers.insert(*(parms->providerName), |
*(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(); | 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); |
} | } |
|
|
} | } |
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, |
|
|
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 |
{ |
cerr<<"--- loading proxy: "<<e.getMessage()<<endl; |
PEG_TRACE((TRC_DISCARDED_DATA,Tracer::LEVEL2, |
#endif |
"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( |
|
|
| |
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(); |
} | } |
|
|
| |
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() |
|
|
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); |
|
|
_provider_ctrl(UNLOAD_IDLE_PROVIDERS, this, (void *)0); | _provider_ctrl(UNLOAD_IDLE_PROVIDERS, this, (void *)0); |
} | } |
catch(...) | catch(...) |
{ | { |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
PEG_TRACE_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(); |
} | } |
| |
|
|
| |
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); |
| |
|
PEG_TRACE(( |
|
TRC_PROVIDERMANAGER, |
|
Tracer::LEVEL4, |
|
"Number of providers in _providers table = %d", |
|
_providers.size ())); |
|
|
// | // |
// Iterate through the _providers table | // Iterate through the _providers table |
// | // |
|
|
} | } |
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; |