version 1.1, 2004/04/30 10:27:25
|
version 1.21, 2008/03/17 08:45:38
|
|
|
//%///////////////////////////////////////////////////////////////////////////// |
//%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 |
|
|
// | // |
//============================================================================== | //============================================================================== |
// | // |
// 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 |
| |
static JMPILocalProviderManager *my_instance = 0; |
|
|
|
JMPILocalProviderManager::JMPILocalProviderManager(void) | JMPILocalProviderManager::JMPILocalProviderManager(void) |
: _idle_timeout(300), _unload_idle_flag(1) |
: _idle_timeout(PEGASUS_PROVIDER_IDLE_TIMEOUT_SECONDS) |
{ | { |
my_instance = this; |
|
} | } |
| |
JMPILocalProviderManager::~JMPILocalProviderManager(void) | JMPILocalProviderManager::~JMPILocalProviderManager(void) |
|
|
_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(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(); |
|
} |
| |
MessageQueue * queue = MessageQueue::lookup(PEGASUS_QUEUENAME_PROVIDERMANAGER_CPP); |
provider = newProvider; |
PEGASUS_ASSERT(queue != 0); |
|
MessageQueueService * service = dynamic_cast<MessageQueueService *>(queue); |
if (0 == (provider->_cimom_handle = new CIMOMHandle())) |
PEGASUS_ASSERT(service != 0); |
{ |
pr = new JMPIProvider(*(parms->providerName), module, &base); |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER,Tracer::LEVEL2, |
if(0 == (pr->_cimom_handle = new CIMOMHandle())) |
"CIMOMhandle is NULL!"); |
|
PEG_METHOD_EXIT(); |
throw NullPointer(); | throw NullPointer(); |
pr->_quantum=0; |
} |
|
|
|
provider->_quantum = 0; |
| |
|
{ |
|
AutoMutex lock(provider->_statusMutex); |
| |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL2, |
"Loading JMPIProvider " + pr->_name); |
"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); |
|
} |
|
|
|
delete newModule; |
| |
// pr->update_idle_timer(); |
if (newProvider) |
|
{ |
|
delete newProvider->_cimom_handle; |
|
} |
| |
_providers.insert(*(parms->providerName), pr); |
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())); |
|
|
|
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); |
} | } |
|
|
} | } |
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) |
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( |
|
|
| |
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(); |
} | } |
| |
| |
// << Tue Jul 29 16:51:25 2003 mdd >> change to run every 300 seconds |
Boolean JMPILocalProviderManager::hasActiveProviders() |
void JMPILocalProviderManager::unload_idle_providers(void) |
|
{ | { |
static struct timeval first = {0,0}, now, last = {0,0}; |
PEG_METHOD_ENTER( |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "ProviderManager::unload_idle_providers"); |
TRC_PROVIDERMANAGER, |
|
"ProviderManager::hasActiveProviders"); |
|
|
|
AutoMutex lock (_providerTableMutex); |
| |
if(first.tv_sec == 0) |
Boolean fRet = _providers.size() > 0; |
gettimeofday(&first, NULL); |
|
gettimeofday(&now, NULL); |
PEG_METHOD_EXIT(); |
if(((now.tv_sec - first.tv_sec) > 300 ) && ( (now.tv_sec - last.tv_sec) > 300)) |
return fRet; |
|
} |
|
|
|
void JMPILocalProviderManager::unloadIdleProviders() |
{ | { |
gettimeofday(&last, NULL); |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, |
if(_unload_idle_flag.value() == 1) |
"ProviderManager::unloadIdleProviders"); |
|
|
|
try |
{ | { |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
AutoMutex lock(_providerTableMutex); |
"Unload Idle Flag Set: Starting JMPIProvider Monitor Thread"); |
|
_unload_idle_flag = 0; |
|
MessageQueueService::get_thread_pool()->allocate_and_awaken(this, provider_monitor); |
|
| |
|
_provider_ctrl(UNLOAD_IDLE_PROVIDERS, this, (void *)0); |
} | } |
|
catch(...) |
|
{ |
|
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
|
"Caught unexpected exception from UNLOAD_IDLE_PROVIDERS."); |
} | } |
|
|
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
} | } |
| |
|
Array <JMPIProvider *> |
PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL JMPILocalProviderManager::provider_monitor(void *parm) |
JMPILocalProviderManager::getIndicationProvidersToEnable () |
{ | { |
Thread *th = reinterpret_cast<Thread *>(parm); |
PEG_METHOD_ENTER (TRC_PROVIDERMANAGER, |
|
"JMPILocalProviderManager::getIndicationProvidersToEnable"); |
| |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "ProviderManager::provider_monitor"); |
Array <JMPIProvider *> enableProviders; |
JMPILocalProviderManager *myself = my_instance ; |
|
| |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Checking for Idle providers to unload."); |
|
try | try |
{ | { |
myself->_provider_ctrl(UNLOAD_IDLE_PROVIDERS, myself, (void *)0); |
AutoMutex lock (_providerTableMutex); |
myself->_unload_idle_flag = 1; |
|
|
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 (CIMException & e) |
|
{ |
|
PEG_TRACE_STRING (TRC_DISCARDED_DATA, Tracer::LEVEL2, |
|
"CIMException: " + e.getMessage ()); |
|
} |
|
catch (Exception & e) |
|
{ |
|
PEG_TRACE_STRING (TRC_DISCARDED_DATA, Tracer::LEVEL2, |
|
"Exception: " + e.getMessage ()); |
} | } |
catch(...) | 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(0); |
return enableProviders; |
} | } |
| |
PEGASUS_NAMESPACE_END |
|
| |
|
PEGASUS_NAMESPACE_END |