version 1.8, 2004/06/22 07:22:20
|
version 1.32, 2006/06/19 20:47:39
|
|
|
//%2003//////////////////////////////////////////////////////////////////////// |
//%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. |
// Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L. P.; | // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L. P.; |
// IBM Corp.; EMC Corporation, The Open Group. | // 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) | // Author: Chip Vincent (cvincent@us.ibm.com) |
// Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com) | // Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com) |
// | // |
// Modified By: |
// Modified By: Seema Gupta(gseema@in.ibm.com) for PEP135 |
|
// Sean Keenan, Hewlett-Packard Company (sean.keenan@hp.com) |
|
// Carol Ann Krug Graves, Hewlett-Packard Company |
|
// (carolann_graves@hp.com) |
|
// Josephine Eskaline Joyce, IBM (jojustin@in.ibm.com) for Bug#2619, #2685,#3354 |
|
// John Alex, IBM (johnalex@us.ibm.com) - Bug#2290 |
// | // |
//%///////////////////////////////////////////////////////////////////////////// | //%///////////////////////////////////////////////////////////////////////////// |
| |
#include "BasicProviderManagerRouter.h" | #include "BasicProviderManagerRouter.h" |
| |
#include <Pegasus/Common/Config.h> | #include <Pegasus/Common/Config.h> |
|
#include <Pegasus/Common/OperationContextInternal.h> |
#include <Pegasus/Common/CIMMessage.h> | #include <Pegasus/Common/CIMMessage.h> |
#include <Pegasus/Common/Tracer.h> | #include <Pegasus/Common/Tracer.h> |
|
#include <Pegasus/Common/Logger.h> |
|
#include <Pegasus/Common/FileSystem.h> |
|
#include <Pegasus/Config/ConfigManager.h> |
#include <Pegasus/ProviderManager2/OperationResponseHandler.h> | #include <Pegasus/ProviderManager2/OperationResponseHandler.h> |
#include <Pegasus/ProviderManager2/ProviderManagerModule.h> | #include <Pegasus/ProviderManager2/ProviderManagerModule.h> |
#include <Pegasus/ProviderManager2/ProviderManager.h> | #include <Pegasus/ProviderManager2/ProviderManager.h> |
| |
// ProviderManager library names. Should these be defined elsewhere? | // ProviderManager library names. Should these be defined elsewhere? |
#if defined(PEGASUS_OS_OS400) | #if defined(PEGASUS_OS_OS400) |
# define LIBRARY_NAME_DEFAULTPM "QSYS/QYCMDFTPVM" |
# define LIBRARY_NAME_DEFAULTPM "QSYS/QYCMPMDE00" |
# define LIBRARY_NAME_CMPIPM "QSYS/QYCMCMPIPM" | # define LIBRARY_NAME_CMPIPM "QSYS/QYCMCMPIPM" |
# define LIBRARY_NAME_JMPIPM "QSYS/QYCMJMPIPM" | # define LIBRARY_NAME_JMPIPM "QSYS/QYCMJMPIPM" |
#else | #else |
# define LIBRARY_NAME_DEFAULTPM "DefaultProviderManager" |
|
# define LIBRARY_NAME_CMPIPM "CMPIProviderManager" | # define LIBRARY_NAME_CMPIPM "CMPIProviderManager" |
# define LIBRARY_NAME_JMPIPM "JMPIProviderManager" | # define LIBRARY_NAME_JMPIPM "JMPIProviderManager" |
#endif | #endif |
| |
PEGASUS_NAMESPACE_BEGIN | PEGASUS_NAMESPACE_BEGIN |
| |
// BEGIN TEMP SECTION |
|
class ProviderManagerContainer | class ProviderManagerContainer |
{ | { |
public: | public: |
ProviderManagerContainer() |
|
: _manager(0) |
|
{ |
|
} |
|
|
|
ProviderManagerContainer(const ProviderManagerContainer & container) |
|
: _manager(0) |
|
{ |
|
*this = container; |
|
} |
|
| |
ProviderManagerContainer( | ProviderManagerContainer( |
const String& physicalName, | const String& physicalName, |
const String& logicalName, | const String& logicalName, |
const String& interfaceName, | const String& interfaceName, |
PEGASUS_INDICATION_CALLBACK indicationCallback) |
PEGASUS_INDICATION_CALLBACK_T indicationCallback, |
|
PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback, |
|
Boolean subscriptionInitComplete) |
: _manager(0) | : _manager(0) |
{ | { |
_physicalName = ProviderManager::_resolvePhysicalName(physicalName); |
#if defined (PEGASUS_OS_VMS) |
|
_physicalName = ConfigManager::getInstance()->getCurrentValue("providerDir") + |
|
String("/") + FileSystem::buildLibraryFileName(physicalName) + String(".exe"); |
|
#elif defined (PEGASUS_OS_OS400) |
|
_physicalName = physicalName; |
|
#else |
|
_physicalName = ConfigManager::getHomedPath(PEGASUS_DEST_LIB_DIR) + |
|
String("/") + FileSystem::buildLibraryFileName(physicalName); |
|
#endif |
| |
_logicalName = logicalName; | _logicalName = logicalName; |
_interfaceName = interfaceName; | _interfaceName = interfaceName; |
| |
_module = ProviderManagerModule(_physicalName); |
_module.reset(new ProviderManagerModule(_physicalName)); |
_module.load(); |
Boolean moduleLoaded = _module->load(); |
| |
_manager = _module.getProviderManager(_logicalName); |
if (moduleLoaded) |
PEGASUS_ASSERT(_manager != 0); |
{ |
|
_manager = _module->getProviderManager(_logicalName); |
_manager->setIndicationCallback(indicationCallback); |
|
} | } |
|
else |
~ProviderManagerContainer() |
|
{ | { |
_module.unload(); |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
|
"ProviderManagerModule load failed."); |
} | } |
| |
ProviderManagerContainer& operator=( |
if (_manager == 0) |
const ProviderManagerContainer & container) |
|
{ |
|
if (this == &container) |
|
{ | { |
return *this; |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
} |
"Failed to load ProviderManager \"" + _physicalName + "\"."); |
| |
_logicalName = container._logicalName; |
Logger::put_l( |
_physicalName = container._physicalName; |
Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE, |
_interfaceName = container._interfaceName; |
"ProviderManager.BasicProviderManagerRouter." |
|
"PROVIDERMANAGER_LOAD_FAILED", |
|
"Failed to load the Provider Manager for interface type \"$0\"" |
|
" from library \"$1\".", |
|
_interfaceName, _physicalName); |
|
|
|
throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, MessageLoaderParms( |
|
"ProviderManager.BasicProviderManagerRouter." |
|
"PROVIDERMANAGER_LOAD_FAILED", |
|
"Failed to load the Provider Manager for interface type \"$0\"" |
|
" from library \"$1\".", |
|
_interfaceName, _physicalName)); |
|
} |
| |
_module = container._module; |
_manager->setIndicationCallback(indicationCallback); |
_manager = container._manager; |
_manager->setResponseChunkCallback(responseChunkCallback); |
| |
return *this; |
_manager->setSubscriptionInitComplete (subscriptionInitComplete); |
} | } |
| |
ProviderManager* getProviderManager() |
ProviderManagerContainer( |
|
const String& interfaceName, |
|
PEGASUS_INDICATION_CALLBACK_T indicationCallback, |
|
PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback, |
|
Boolean subscriptionInitComplete, |
|
ProviderManager* manager) |
|
: |
|
_interfaceName(interfaceName), |
|
_manager(manager), |
|
_module(0) |
{ | { |
return _manager; |
_manager->setIndicationCallback(indicationCallback); |
|
_manager->setResponseChunkCallback(responseChunkCallback); |
|
_manager->setSubscriptionInitComplete(subscriptionInitComplete); |
} | } |
| |
const String& getPhysicalName() const |
~ProviderManagerContainer() |
{ | { |
return _physicalName; |
delete _manager; |
|
|
|
if (_module.get()) |
|
_module->unload(); |
} | } |
| |
const String& getLogicalName() const |
ProviderManager* getProviderManager() |
{ | { |
return _logicalName; |
return _manager; |
} | } |
| |
const String& getInterfaceName() const | const String& getInterfaceName() const |
|
|
return _interfaceName; | return _interfaceName; |
} | } |
| |
|
|
private: | private: |
|
|
|
ProviderManagerContainer(); |
|
ProviderManagerContainer& operator=(const ProviderManagerContainer&); |
|
ProviderManagerContainer(const ProviderManagerContainer&); |
|
|
String _physicalName; | String _physicalName; |
String _logicalName; | String _logicalName; |
String _interfaceName; | String _interfaceName; |
|
|
ProviderManagerModule _module; |
|
ProviderManager* _manager; | ProviderManager* _manager; |
|
AutoPtr<ProviderManagerModule> _module; |
}; | }; |
// END TEMP SECTION |
|
| |
|
PEGASUS_INDICATION_CALLBACK_T |
|
BasicProviderManagerRouter::_indicationCallback = 0; |
| |
PEGASUS_INDICATION_CALLBACK BasicProviderManagerRouter::_indicationCallback = 0; |
PEGASUS_RESPONSE_CHUNK_CALLBACK_T |
|
BasicProviderManagerRouter::_responseChunkCallback = 0; |
| |
// Private, unimplemented constructor |
ProviderManager* |
BasicProviderManagerRouter::BasicProviderManagerRouter() |
(*BasicProviderManagerRouter::_createDefaultProviderManagerCallback)() = 0; |
{ |
|
} |
|
| |
BasicProviderManagerRouter::BasicProviderManagerRouter( | BasicProviderManagerRouter::BasicProviderManagerRouter( |
PEGASUS_INDICATION_CALLBACK indicationCallback) |
PEGASUS_INDICATION_CALLBACK_T indicationCallback, |
|
PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback, |
|
ProviderManager* (*createDefaultProviderManagerCallback)()) |
{ | { |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, | PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, |
"BasicProviderManagerRouter::BasicProviderManagerRouter"); | "BasicProviderManagerRouter::BasicProviderManagerRouter"); |
| |
_indicationCallback = indicationCallback; | _indicationCallback = indicationCallback; |
|
_responseChunkCallback = responseChunkCallback; |
|
_subscriptionInitComplete = false; |
|
_createDefaultProviderManagerCallback = |
|
createDefaultProviderManagerCallback; |
| |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
} | } |
|
|
{ | { |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, | PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, |
"BasicProviderManagerRouter::~BasicProviderManagerRouter"); | "BasicProviderManagerRouter::~BasicProviderManagerRouter"); |
|
/* Clean up the provider managers */ |
|
for (Uint32 i = 0, n = _providerManagerTable.size(); i < n; i++) |
|
{ |
|
ProviderManagerContainer* pmc=_providerManagerTable[i]; |
|
delete pmc; |
|
} |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
} | } |
| |
|
|
// Provider information is in CIMIndicationRequestMessage | // Provider information is in CIMIndicationRequestMessage |
CIMIndicationRequestMessage* indReq = | CIMIndicationRequestMessage* indReq = |
dynamic_cast<CIMIndicationRequestMessage*>(request); | dynamic_cast<CIMIndicationRequestMessage*>(request); |
providerModule = indReq->providerModule; |
ProviderIdContainer pidc = indReq->operationContext.get(ProviderIdContainer::NAME); |
|
providerModule = pidc.getModule(); |
} | } |
else if (request->getType() == CIM_ENABLE_MODULE_REQUEST_MESSAGE) | else if (request->getType() == CIM_ENABLE_MODULE_REQUEST_MESSAGE) |
{ | { |
|
|
providerModule = dmReq->providerModule; | providerModule = dmReq->providerModule; |
} | } |
else if ((request->getType() == CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE) || | else if ((request->getType() == CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE) || |
|
(request->getType() == |
|
CIM_SUBSCRIPTION_INIT_COMPLETE_REQUEST_MESSAGE) || |
(request->getType() == CIM_NOTIFY_CONFIG_CHANGE_REQUEST_MESSAGE)) | (request->getType() == CIM_NOTIFY_CONFIG_CHANGE_REQUEST_MESSAGE)) |
{ | { |
// This operation is not provider-specific | // This operation is not provider-specific |
|
|
// Forward the request to the appropriate ProviderManager(s) | // Forward the request to the appropriate ProviderManager(s) |
// | // |
| |
if (request->getType() == CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE) |
if ((request->getType() == CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE) || |
|
(request->getType() == |
|
CIM_SUBSCRIPTION_INIT_COMPLETE_REQUEST_MESSAGE)) |
{ | { |
// Send CIMStopAllProvidersRequestMessage to all ProviderManagers |
_subscriptionInitComplete = true; |
|
|
|
// Send CIMStopAllProvidersRequestMessage or |
|
// CIMSubscriptionInitCompleteRequestMessage to all ProviderManagers |
ReadLock tableLock(_providerManagerTableLock); | ReadLock tableLock(_providerManagerTableLock); |
for (Uint32 i = 0, n = _providerManagerTable.size(); i < n; i++) | for (Uint32 i = 0, n = _providerManagerTable.size(); i < n; i++) |
{ | { |
ProviderManagerContainer* pmc=_providerManagerTable[i]; | ProviderManagerContainer* pmc=_providerManagerTable[i]; |
Message* resp = pmc->getProviderManager()->processMessage(request); | Message* resp = pmc->getProviderManager()->processMessage(request); |
if (resp) |
|
{ |
|
delete resp; | delete resp; |
} | } |
} |
|
| |
response = request->buildResponse(); | response = request->buildResponse(); |
} | } |
|
|
providerModule.findProperty("InterfaceType")).getValue(); | providerModule.findProperty("InterfaceType")).getValue(); |
itValue.get(interfaceType); | itValue.get(interfaceType); |
| |
|
ProviderManager* pm = 0; |
|
Boolean gotError = false; |
|
try |
|
{ |
// Look up the appropriate ProviderManager by InterfaceType | // Look up the appropriate ProviderManager by InterfaceType |
ProviderManager* pm = _lookupProviderManager(interfaceType); |
pm = _lookupProviderManager(interfaceType); |
if (remoteNameSpaceRequest && !pm->supportsRemoteNameSpaces()) { |
} |
|
catch (const CIMException& e) |
|
{ |
|
CIMResponseMessage* cimResponse = request->buildResponse(); |
|
cimResponse->cimException = e; |
|
response = cimResponse; |
|
gotError = true; |
|
} |
|
|
|
if (remoteNameSpaceRequest && !pm->supportsRemoteNameSpaces()) |
|
{ |
CIMResponseMessage* resp = request->buildResponse(); | CIMResponseMessage* resp = request->buildResponse(); |
resp->cimException = PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, | resp->cimException = PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, |
"Remote Namespace operations not supported for interface type "+interfaceType); |
"Remote Namespace operations not supported for interface type " |
|
+ interfaceType); |
response = resp; | response = resp; |
|
gotError = true; |
|
} |
|
|
|
if (!gotError) |
|
{ |
|
response = pm->processMessage(request); |
} | } |
else response = pm->processMessage(request); |
|
} | } |
| |
// preserve message key | // preserve message key |
response->setKey(request->getKey()); |
|
|
|
// set HTTP method in response from request | // set HTTP method in response from request |
response->setHttpMethod(request->getHttpMethod()); |
// set closeConnect |
|
((CIMResponseMessage *)response)->syncAttributes(request); |
| |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
return response; | return response; |
|
|
// another temporary solution for converting a generic file name into | // another temporary solution for converting a generic file name into |
// a file name useable by each platform. | // a file name useable by each platform. |
| |
#if defined(ENABLE_DEFAULT_PROVIDER_MANAGER) |
// The DefaultProviderManager is now statically linked rather than |
if (interfaceType == "C++Default") |
// dynamically loaded. This code is no longer used but remains for |
|
// reference purposes. |
|
|
|
#if defined(PEGASUS_ENABLE_DEFAULT_PROVIDER_MANAGER) |
|
if (interfaceType == "C++Default" && |
|
_createDefaultProviderManagerCallback) |
{ | { |
|
ProviderManager* pm = (*_createDefaultProviderManagerCallback)(); |
ProviderManagerContainer* pmc = new ProviderManagerContainer( | ProviderManagerContainer* pmc = new ProviderManagerContainer( |
LIBRARY_NAME_DEFAULTPM, "DEFAULT", "C++Default", |
"C++Default", |
_indicationCallback); |
_indicationCallback, |
|
_responseChunkCallback, |
|
_subscriptionInitComplete, |
|
pm); |
_providerManagerTable.append(pmc); | _providerManagerTable.append(pmc); |
return pmc->getProviderManager(); | return pmc->getProviderManager(); |
} | } |
#endif | #endif |
| |
#if defined(ENABLE_CMPI_PROVIDER_MANAGER) |
#if defined(PEGASUS_ENABLE_CMPI_PROVIDER_MANAGER) |
if (interfaceType == "CMPI") | if (interfaceType == "CMPI") |
{ | { |
ProviderManagerContainer* pmc = new ProviderManagerContainer( | ProviderManagerContainer* pmc = new ProviderManagerContainer( |
LIBRARY_NAME_CMPIPM, "CMPI", "CMPI", _indicationCallback); |
LIBRARY_NAME_CMPIPM, |
|
"CMPI", |
|
"CMPI", |
|
_indicationCallback, |
|
_responseChunkCallback, |
|
_subscriptionInitComplete); |
_providerManagerTable.append(pmc); | _providerManagerTable.append(pmc); |
return pmc->getProviderManager(); | return pmc->getProviderManager(); |
} | } |
#endif | #endif |
| |
#if defined(ENABLE_JMPI_PROVIDER_MANAGER) |
#if defined(PEGASUS_ENABLE_JMPI_PROVIDER_MANAGER) |
if (interfaceType == "JMPI") |
if ( interfaceType == "JMPI" |
|
|| interfaceType == "JMPIExperimental" |
|
) |
{ | { |
ProviderManagerContainer* pmc = new ProviderManagerContainer( | ProviderManagerContainer* pmc = new ProviderManagerContainer( |
LIBRARY_NAME_JMPIPM, "JMPI", "JMPI", _indicationCallback); |
LIBRARY_NAME_JMPIPM, |
|
interfaceType, |
|
interfaceType, |
|
_indicationCallback, |
|
_responseChunkCallback, |
|
_subscriptionInitComplete); |
_providerManagerTable.append(pmc); | _providerManagerTable.append(pmc); |
return pmc->getProviderManager(); | return pmc->getProviderManager(); |
} | } |