version 1.1, 2003/08/18 04:27:16
|
version 1.71, 2006/08/29 17:48:56
|
|
|
//%///////////////////////////////////////////////////////////////////////////// |
//%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: Carol Ann Krug Graves, Hewlett-Packard Company |
|
// (carolann_graves@hp.com) |
|
// Mike Day, IBM (mdday@us.ibm.com) |
|
// Karl Schopmeyer(k.schopmeyer@opengroup.org) - Fix associators. |
|
// Yi Zhou, Hewlett-Packard Company (yi_zhou@hp.com) |
|
// |
|
//%///////////////////////////////////////////////////////////////////////////// | //%///////////////////////////////////////////////////////////////////////////// |
| |
#include "DefaultProviderManager.h" | #include "DefaultProviderManager.h" |
| |
#include <Pegasus/Common/CIMMessage.h> | #include <Pegasus/Common/CIMMessage.h> |
#include <Pegasus/Common/OperationContext.h> | #include <Pegasus/Common/OperationContext.h> |
#include <Pegasus/Common/Destroyer.h> |
#include <Pegasus/Common/Time.h> |
#include <Pegasus/Common/Tracer.h> | #include <Pegasus/Common/Tracer.h> |
#include <Pegasus/Common/StatisticalData.h> | #include <Pegasus/Common/StatisticalData.h> |
#include <Pegasus/Common/Logger.h> | #include <Pegasus/Common/Logger.h> |
#include <Pegasus/Common/MessageLoader.h> //l10n |
#include <Pegasus/Common/MessageLoader.h> |
|
#include <Pegasus/Common/PegasusVersion.h> |
#include <Pegasus/Config/ConfigManager.h> |
#include <Pegasus/Common/Constants.h> |
| |
#include <Pegasus/ProviderManager2/Default/Provider.h> |
#include <Pegasus/Query/QueryExpression/QueryExpression.h> |
#include <Pegasus/ProviderManager2/Default/OperationResponseHandler.h> |
#include <Pegasus/ProviderManager2/QueryExpressionFactory.h> |
| |
#include <Pegasus/Server/ProviderRegistrationManager/ProviderRegistrationManager.h> |
#include <Pegasus/ProviderManager2/OperationResponseHandler.h> |
| |
PEGASUS_NAMESPACE_BEGIN | PEGASUS_NAMESPACE_BEGIN |
| |
// auto variable to protect provider during operations |
// |
class pm_service_op_lock |
// Default Provider Manager |
{ |
// |
private: |
DefaultProviderManager::DefaultProviderManager() |
pm_service_op_lock(void); |
|
|
|
public: |
|
pm_service_op_lock(Provider *provider) : _provider(provider) |
|
{ | { |
_provider->protect(); |
_subscriptionInitComplete = false; |
} | } |
| |
~pm_service_op_lock(void) |
DefaultProviderManager::~DefaultProviderManager() |
{ | { |
_provider->unprotect(); |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, |
} |
"DefaultProviderManager::~DefaultProviderManager"); |
|
|
Provider * _provider; |
|
}; |
|
|
|
// |
|
// Provider module status |
|
// |
|
static const Uint16 _MODULE_OK = 2; |
|
static const Uint16 _MODULE_STOPPING = 9; |
|
static const Uint16 _MODULE_STOPPED = 10; |
|
| |
// provider manager |
_shutdownAllProviders(); |
LocalProviderManager providerManager; |
|
| |
DefaultProviderManager::DefaultProviderManager(void) |
for (ProviderTable::Iterator i = _providers.start(); i != 0; i++) |
{ | { |
|
ProviderMessageHandler* provider = i.value(); |
|
delete provider; |
} | } |
| |
DefaultProviderManager::~DefaultProviderManager(void) |
for (ModuleTable::Iterator j = _modules.start(); j != 0; j++) |
{ | { |
|
ProviderModule* module = j.value(); |
|
delete module; |
|
} |
|
|
|
PEG_METHOD_EXIT(); |
} | } |
| |
Message * DefaultProviderManager::processMessage(Message * request) | Message * DefaultProviderManager::processMessage(Message * request) |
|
|
switch(request->getType()) | switch(request->getType()) |
{ | { |
case CIM_GET_INSTANCE_REQUEST_MESSAGE: | case CIM_GET_INSTANCE_REQUEST_MESSAGE: |
response = handleGetInstanceRequest(request); |
|
|
|
break; |
|
case CIM_ENUMERATE_INSTANCES_REQUEST_MESSAGE: | case CIM_ENUMERATE_INSTANCES_REQUEST_MESSAGE: |
response = handleEnumerateInstancesRequest(request); |
|
|
|
break; |
|
case CIM_ENUMERATE_INSTANCE_NAMES_REQUEST_MESSAGE: | case CIM_ENUMERATE_INSTANCE_NAMES_REQUEST_MESSAGE: |
response = handleEnumerateInstanceNamesRequest(request); |
|
|
|
break; |
|
case CIM_CREATE_INSTANCE_REQUEST_MESSAGE: | case CIM_CREATE_INSTANCE_REQUEST_MESSAGE: |
response = handleCreateInstanceRequest(request); |
|
|
|
break; |
|
case CIM_MODIFY_INSTANCE_REQUEST_MESSAGE: | case CIM_MODIFY_INSTANCE_REQUEST_MESSAGE: |
response = handleModifyInstanceRequest(request); |
|
|
|
break; |
|
case CIM_DELETE_INSTANCE_REQUEST_MESSAGE: | case CIM_DELETE_INSTANCE_REQUEST_MESSAGE: |
response = handleDeleteInstanceRequest(request); |
|
|
|
break; |
|
case CIM_EXEC_QUERY_REQUEST_MESSAGE: | case CIM_EXEC_QUERY_REQUEST_MESSAGE: |
response = handleExecuteQueryRequest(request); |
|
|
|
break; |
|
case CIM_ASSOCIATORS_REQUEST_MESSAGE: | case CIM_ASSOCIATORS_REQUEST_MESSAGE: |
response = handleAssociatorsRequest(request); |
|
|
|
break; |
|
case CIM_ASSOCIATOR_NAMES_REQUEST_MESSAGE: | case CIM_ASSOCIATOR_NAMES_REQUEST_MESSAGE: |
response = handleAssociatorNamesRequest(request); |
|
|
|
break; |
|
case CIM_REFERENCES_REQUEST_MESSAGE: | case CIM_REFERENCES_REQUEST_MESSAGE: |
response = handleReferencesRequest(request); |
|
|
|
break; |
|
case CIM_REFERENCE_NAMES_REQUEST_MESSAGE: | case CIM_REFERENCE_NAMES_REQUEST_MESSAGE: |
response = handleReferenceNamesRequest(request); |
|
|
|
break; |
|
case CIM_GET_PROPERTY_REQUEST_MESSAGE: | case CIM_GET_PROPERTY_REQUEST_MESSAGE: |
response = handleGetPropertyRequest(request); |
|
|
|
break; |
|
case CIM_SET_PROPERTY_REQUEST_MESSAGE: | case CIM_SET_PROPERTY_REQUEST_MESSAGE: |
response = handleSetPropertyRequest(request); |
|
|
|
break; |
|
case CIM_INVOKE_METHOD_REQUEST_MESSAGE: | case CIM_INVOKE_METHOD_REQUEST_MESSAGE: |
response = handleInvokeMethodRequest(request); |
|
|
|
break; |
|
case CIM_CREATE_SUBSCRIPTION_REQUEST_MESSAGE: | case CIM_CREATE_SUBSCRIPTION_REQUEST_MESSAGE: |
response = handleCreateSubscriptionRequest(request); |
|
|
|
break; |
|
case CIM_MODIFY_SUBSCRIPTION_REQUEST_MESSAGE: | case CIM_MODIFY_SUBSCRIPTION_REQUEST_MESSAGE: |
response = handleModifySubscriptionRequest(request); |
|
|
|
break; |
|
case CIM_DELETE_SUBSCRIPTION_REQUEST_MESSAGE: | case CIM_DELETE_SUBSCRIPTION_REQUEST_MESSAGE: |
response = handleDeleteSubscriptionRequest(request); |
case CIM_EXPORT_INDICATION_REQUEST_MESSAGE: |
|
{ |
|
CIMRequestMessage* cimRequest = |
|
dynamic_cast<CIMRequestMessage*>(request); |
| |
break; |
// resolve provider name |
case CIM_ENABLE_INDICATIONS_REQUEST_MESSAGE: |
ProviderName name = _resolveProviderName( |
response = handleEnableIndicationsRequest(request); |
cimRequest->operationContext.get(ProviderIdContainer::NAME)); |
| |
break; |
// get cached or load new provider module |
case CIM_DISABLE_INDICATIONS_REQUEST_MESSAGE: |
ProviderOperationCounter poc( |
response = handleDisableIndicationsRequest(request); |
_getProvider(name.getPhysicalName(), name.getLogicalName())); |
| |
|
response = poc.GetProvider().processMessage(cimRequest); |
break; | break; |
case CIM_CONSUME_INDICATION_REQUEST_MESSAGE: |
} |
response = handleConsumeIndicationRequest(request); |
|
break; |
|
| |
case CIM_DISABLE_MODULE_REQUEST_MESSAGE: | case CIM_DISABLE_MODULE_REQUEST_MESSAGE: |
response = handleDisableModuleRequest(request); |
response = _handleDisableModuleRequest(request); |
|
|
break; | break; |
case CIM_ENABLE_MODULE_REQUEST_MESSAGE: |
|
response = handleEnableModuleRequest(request); |
|
| |
|
case CIM_ENABLE_MODULE_REQUEST_MESSAGE: |
|
response = _handleEnableModuleRequest(request); |
break; | break; |
case CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE: |
|
response = handleStopAllProvidersRequest(request); |
|
| |
|
case CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE: |
|
response = _handleStopAllProvidersRequest(request); |
break; | break; |
default: |
|
response = handleUnsupportedRequest(request); |
|
| |
|
case CIM_INITIALIZE_PROVIDER_REQUEST_MESSAGE: |
|
response = _handleInitializeProviderRequest(request); |
break; | break; |
} |
|
| |
PEG_METHOD_EXIT(); |
case CIM_SUBSCRIPTION_INIT_COMPLETE_REQUEST_MESSAGE: |
|
response = _handleSubscriptionInitCompleteRequest(request); |
|
break; |
| |
return(response); |
default: |
|
PEGASUS_ASSERT(0); |
|
break; |
} | } |
| |
Message * DefaultProviderManager::handleUnsupportedRequest(const Message * message) throw() |
|
{ |
|
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleUnsupportedRequest"); |
|
|
|
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| |
// a null response implies unsupported or unknown operation |
return response; |
return(0); |
|
} | } |
| |
Message * DefaultProviderManager::handleGetInstanceRequest(const Message * message) throw() |
Message* DefaultProviderManager::_handleInitializeProviderRequest( |
|
Message* message) |
{ | { |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleGetInstanceRequest"); |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, |
|
"DefaultProviderManager::_handleInitializeProviderRequest"); |
CIMGetInstanceRequestMessage * request = |
|
dynamic_cast<CIMGetInstanceRequestMessage *>(const_cast<Message *>(message)); |
|
| |
|
CIMInitializeProviderRequestMessage* request = |
|
dynamic_cast<CIMInitializeProviderRequestMessage*>(message); |
PEGASUS_ASSERT(request != 0); | PEGASUS_ASSERT(request != 0); |
| |
CIMGetInstanceResponseMessage * response = |
CIMInitializeProviderResponseMessage* response = |
new CIMGetInstanceResponseMessage( |
dynamic_cast<CIMInitializeProviderResponseMessage*>( |
request->messageId, |
request->buildResponse()); |
CIMException(), |
|
request->queueIds.copyAndPop(), |
|
CIMInstance()); |
|
|
|
PEGASUS_ASSERT(response != 0); | PEGASUS_ASSERT(response != 0); |
| |
// preserve message key |
|
response->setKey(request->getKey()); |
|
|
|
// Set HTTP method in response from request |
|
response->setHttpMethod(request->getHttpMethod()); |
|
|
|
// create a handler for this request |
|
GetInstanceResponseHandler handler(request, response); |
|
|
|
try | try |
{ | { |
Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
// resolve provider name |
"DefaultProviderManager::handleGetInstanceRequest - Host name: $0 Name space: $1 Class name: $2", |
ProviderName name = _resolveProviderName( |
System::getHostName(), |
request->operationContext.get(ProviderIdContainer::NAME)); |
request->nameSpace.getString(), |
|
request->instanceName.getClassName().getString()); |
|
|
|
// make target object path |
|
CIMObjectPath objectPath( |
|
System::getHostName(), |
|
request->nameSpace, |
|
request->instanceName.getClassName(), |
|
request->instanceName.getKeyBindings()); |
|
|
|
InternalProviderName name( |
|
String::EMPTY, |
|
String::EMPTY, |
|
objectPath.toString()); |
|
|
|
name = findProvider(name.toString()); |
|
| |
// get cached or load new provider module | // get cached or load new provider module |
OpProviderHolder ph = |
ProviderOperationCounter poc( |
providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY); |
_getProvider(name.getPhysicalName(), name.getLogicalName())); |
|
|
// convert arguments |
|
OperationContext context; |
|
|
|
context.insert(IdentityContainer(request->userName)); |
|
context.insert(AcceptLanguageListContainer(request->acceptLanguages)); |
|
context.insert(ContentLanguageListContainer(request->contentLanguages)); |
|
|
|
CIMPropertyList propertyList(request->propertyList); |
|
|
|
// forward request |
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Calling provider.getInstance: " + |
|
ph.GetProvider().getName()); |
|
|
|
pm_service_op_lock op_lock(&ph.GetProvider()); |
|
|
|
STAT_GETSTARTTIME; |
|
|
|
ph.GetProvider().getInstance( |
|
context, |
|
objectPath, |
|
request->includeQualifiers, |
|
request->includeClassOrigin, |
|
propertyList, |
|
handler); |
|
|
|
STAT_PMS_PROVIDEREND; |
|
} | } |
catch(CIMException & e) | catch(CIMException & e) |
{ | { |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL3, |
"Exception: " + e.getMessage()); |
"CIMException: " + e.getMessage()); |
| |
handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n |
response->cimException = PEGASUS_CIM_EXCEPTION_LANG( |
|
e.getContentLanguages(), e.getCode(), e.getMessage()); |
} | } |
catch(Exception & e) | catch(Exception & e) |
{ | { |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL3, |
"Exception: " + e.getMessage()); | "Exception: " + e.getMessage()); |
handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n |
|
|
response->cimException = PEGASUS_CIM_EXCEPTION_LANG( |
|
e.getContentLanguages(), CIM_ERR_FAILED, e.getMessage()); |
} | } |
catch(...) | catch(...) |
{ | { |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL3, |
"Exception: Unknown"); | "Exception: Unknown"); |
handler.setStatus(CIM_ERR_FAILED, "Unknown error."); |
|
|
response->cimException = PEGASUS_CIM_EXCEPTION( |
|
CIM_ERR_FAILED, "Unknown error."); |
} | } |
| |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
|
return response; |
return(response); |
|
} | } |
| |
Message * DefaultProviderManager::handleEnumerateInstancesRequest(const Message * message) throw() |
Message* DefaultProviderManager::_handleDisableModuleRequest(Message* message) |
{ | { |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleEnumerateInstanceRequest"); |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, |
|
"DefaultProviderManager::_handleDisableModuleRequest"); |
CIMEnumerateInstancesRequestMessage * request = |
|
dynamic_cast<CIMEnumerateInstancesRequestMessage *>(const_cast<Message *>(message)); |
|
| |
|
CIMDisableModuleRequestMessage* request = |
|
dynamic_cast<CIMDisableModuleRequestMessage*>(message); |
PEGASUS_ASSERT(request != 0); | PEGASUS_ASSERT(request != 0); |
| |
CIMEnumerateInstancesResponseMessage * response = |
Array<Uint16> operationalStatus; |
new CIMEnumerateInstancesResponseMessage( |
CIMException cimException; |
request->messageId, |
|
CIMException(), |
|
request->queueIds.copyAndPop(), |
|
Array<CIMInstance>()); |
|
|
|
PEGASUS_ASSERT(response != 0); |
|
|
|
// preserve message key |
|
response->setKey(request->getKey()); |
|
|
|
// Set HTTP method in response from request |
|
response->setHttpMethod (request->getHttpMethod ()); |
|
|
|
// create a handler for this request |
|
EnumerateInstancesResponseHandler handler(request, response); |
|
| |
try | try |
{ | { |
Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
// get provider module name |
"DefaultProviderManager::handleEnumerateInstancesRequest - Host name: $0 Name space: $1 Class name: $2", |
String moduleName; |
System::getHostName(), |
CIMInstance mInstance = request->providerModule; |
request->nameSpace.getString(), |
Uint32 pos = mInstance.findProperty(CIMName("Name")); |
request->className.getString()); |
PEGASUS_ASSERT(pos != PEG_NOT_FOUND); |
|
mInstance.getProperty(pos).getValue().get(moduleName); |
// make target object path |
|
CIMObjectPath objectPath( |
|
System::getHostName(), |
|
request->nameSpace, |
|
request->className); |
|
|
|
InternalProviderName name( |
|
String::EMPTY, |
|
String::EMPTY, |
|
objectPath.toString()); |
|
|
|
name = findProvider(name.toString()); |
|
|
|
// get cached or load new provider module |
|
OpProviderHolder ph = |
|
providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY); |
|
|
|
// convert arguments |
|
OperationContext context; |
|
|
|
context.insert(IdentityContainer(request->userName)); |
|
context.insert(AcceptLanguageListContainer(request->acceptLanguages)); |
|
context.insert(ContentLanguageListContainer(request->contentLanguages)); |
|
|
|
CIMPropertyList propertyList(request->propertyList); |
|
| |
// forward request |
// |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
// Unload providers |
"Calling provider.enumerateInstances: " + |
// |
ph.GetProvider().getName()); |
Array<CIMInstance> providerInstances = request->providers; |
| |
pm_service_op_lock op_lock(&ph.GetProvider()); |
String physicalName = _resolvePhysicalName( |
|
mInstance.getProperty( |
|
mInstance.findProperty("Location")).getValue().toString()); |
| |
STAT_GETSTARTTIME; |
for (Uint32 i = 0, n = providerInstances.size(); i < n; i++) |
|
{ |
|
String pName; |
|
providerInstances[i].getProperty( |
|
providerInstances[i].findProperty("Name")). |
|
getValue().get(pName); |
| |
ph.GetProvider().enumerateInstances( |
Sint16 ret_value = _disableProvider(pName); |
context, |
|
objectPath, |
|
request->includeQualifiers, |
|
request->includeClassOrigin, |
|
propertyList, |
|
handler); |
|
| |
STAT_PMS_PROVIDEREND; |
if (ret_value == 0) |
|
{ |
|
// disable failed since there are pending requests, |
|
// stop trying to disable other providers in this module. |
|
operationalStatus.append(CIM_MSE_OPSTATUS_VALUE_OK); |
|
break; |
|
} |
|
else if (ret_value != 1) // Not success |
|
{ |
|
// disable failed for other reason, throw exception |
|
throw PEGASUS_CIM_EXCEPTION_L( |
|
CIM_ERR_FAILED, |
|
MessageLoaderParms( |
|
"ProviderManager.ProviderManagerService." |
|
"DISABLE_PROVIDER_FAILED", |
|
"Failed to disable the provider.")); |
|
} |
|
} |
} | } |
catch(CIMException & e) | catch(CIMException & e) |
{ | { |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, | PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
"Exception: " + e.getMessage()); | "Exception: " + e.getMessage()); |
handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n |
cimException = e; |
} | } |
catch(Exception & e) | catch(Exception & e) |
{ | { |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, | PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
"Exception: " + e.getMessage()); | "Exception: " + e.getMessage()); |
handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n |
cimException = CIMException(CIM_ERR_FAILED, e.getMessage()); |
} | } |
catch(...) | catch(...) |
{ | { |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, | PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
"Exception: Unknown"); | "Exception: Unknown"); |
handler.setStatus(CIM_ERR_FAILED, "Unknown error."); |
cimException = PEGASUS_CIM_EXCEPTION_L( |
|
CIM_ERR_FAILED, |
|
MessageLoaderParms( |
|
"ProviderManager.ProviderManagerService.UNKNOWN_ERROR", |
|
"Unknown Error")); |
|
} |
|
|
|
if (cimException.getCode() == CIM_ERR_SUCCESS) |
|
{ |
|
// Status is set to OK if a provider was busy |
|
if (operationalStatus.size() == 0) |
|
{ |
|
operationalStatus.append(CIM_MSE_OPSTATUS_VALUE_STOPPED); |
|
} |
|
} |
|
else |
|
{ |
|
// If exception occurs, module is not stopped |
|
operationalStatus.append(CIM_MSE_OPSTATUS_VALUE_OK); |
} | } |
| |
|
CIMDisableModuleResponseMessage* response = |
|
dynamic_cast<CIMDisableModuleResponseMessage*>( |
|
request->buildResponse()); |
|
PEGASUS_ASSERT(response != 0); |
|
|
|
response->operationalStatus = operationalStatus; |
|
|
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| |
return(response); |
return response; |
} | } |
| |
Message * DefaultProviderManager::handleEnumerateInstanceNamesRequest(const Message * message) throw() |
Message* DefaultProviderManager::_handleEnableModuleRequest(Message* message) |
{ | { |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleEnumerateInstanceNamesRequest"); |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, |
|
"DefaultProviderManager::_handleEnableModuleRequest"); |
CIMEnumerateInstanceNamesRequestMessage * request = |
|
dynamic_cast<CIMEnumerateInstanceNamesRequestMessage *>(const_cast<Message *>(message)); |
|
| |
|
CIMEnableModuleRequestMessage* request = |
|
dynamic_cast<CIMEnableModuleRequestMessage*>(message); |
PEGASUS_ASSERT(request != 0); | PEGASUS_ASSERT(request != 0); |
| |
CIMEnumerateInstanceNamesResponseMessage * response = |
Array<Uint16> operationalStatus; |
new CIMEnumerateInstanceNamesResponseMessage( |
operationalStatus.append(CIM_MSE_OPSTATUS_VALUE_OK); |
request->messageId, |
|
CIMException(), |
|
request->queueIds.copyAndPop(), |
|
Array<CIMObjectPath>()); |
|
| |
|
CIMEnableModuleResponseMessage* response = |
|
dynamic_cast<CIMEnableModuleResponseMessage*>( |
|
request->buildResponse()); |
PEGASUS_ASSERT(response != 0); | PEGASUS_ASSERT(response != 0); |
| |
// preserve message key |
response->operationalStatus = operationalStatus; |
response->setKey(request->getKey()); |
|
|
|
//set HTTP method in response from request |
|
response->setHttpMethod(request->getHttpMethod());; |
|
| |
// create a handler for this request |
PEG_METHOD_EXIT(); |
EnumerateInstanceNamesResponseHandler handler(request, response); |
return response; |
|
} |
| |
// process the request |
Message* DefaultProviderManager::_handleStopAllProvidersRequest( |
try |
Message* message) |
{ | { |
Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, |
"DefaultProviderManager::handleEnumerateInstanceNamesRequest - Host name: $0 Name space: $1 Class name: $2", |
"DefaultProviderManager::_handleStopAllProvidersRequest"); |
System::getHostName(), |
|
request->nameSpace.getString(), |
|
request->className.getString()); |
|
|
|
// make target object path |
|
CIMObjectPath objectPath( |
|
System::getHostName(), |
|
request->nameSpace, |
|
request->className); |
|
|
|
// build an internal provider name from the request arguments |
|
InternalProviderName name( |
|
String::EMPTY, |
|
String::EMPTY, |
|
objectPath.toString()); |
|
| |
// resolve the physical and logical provider name |
CIMStopAllProvidersRequestMessage* request = |
name = findProvider(name.toString()); |
dynamic_cast<CIMStopAllProvidersRequestMessage*>(message); |
|
PEGASUS_ASSERT(request != 0); |
| |
// get cached or load new provider module |
CIMStopAllProvidersResponseMessage* response = |
OpProviderHolder ph = |
dynamic_cast<CIMStopAllProvidersResponseMessage*>( |
providerManager.getProvider(name.getPhysicalName(), name.getLogicalName()); |
request->buildResponse()); |
|
PEGASUS_ASSERT(response != 0); |
| |
// convert arguments |
// tell the provider manager to shutdown all the providers |
OperationContext context; |
_shutdownAllProviders(); |
| |
context.insert(IdentityContainer(request->userName)); |
PEG_METHOD_EXIT(); |
context.insert(AcceptLanguageListContainer(request->acceptLanguages)); |
return response; |
context.insert(ContentLanguageListContainer(request->contentLanguages)); |
} |
| |
// forward request |
Message* DefaultProviderManager::_handleSubscriptionInitCompleteRequest( |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
Message* message) |
"Calling provider.enumerateInstanceNames: " + |
{ |
ph.GetProvider().getName()); |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, |
|
"DefaultProviderManager::_handleSubscriptionInitCompleteRequest"); |
|
|
|
CIMSubscriptionInitCompleteRequestMessage* request = |
|
dynamic_cast<CIMSubscriptionInitCompleteRequestMessage*>(message); |
|
PEGASUS_ASSERT(request != 0); |
| |
pm_service_op_lock op_lock(&ph.GetProvider()); |
CIMSubscriptionInitCompleteResponseMessage* response = |
|
dynamic_cast<CIMSubscriptionInitCompleteResponseMessage*>( |
|
request->buildResponse()); |
|
PEGASUS_ASSERT(response != 0); |
| |
STAT_GETSTARTTIME; |
_subscriptionInitComplete = true; |
| |
ph.GetProvider().enumerateInstanceNames( |
// Make a copy of the table so it is not locked during the provider calls |
context, |
Array<ProviderMessageHandler*> providerList; |
objectPath, |
{ |
handler); |
AutoMutex lock(_providerTableMutex); |
| |
STAT_PMS_PROVIDEREND; |
for (ProviderTable::Iterator i = _providers.start(); i != 0; i++) |
} |
|
catch(CIMException & e) |
|
{ | { |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
providerList.append(i.value()); |
"Exception: " + e.getMessage()); |
|
handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n |
|
} | } |
catch(Exception & e) |
|
{ |
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Exception: " + e.getMessage()); |
|
handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n |
|
} | } |
catch(...) |
|
|
// |
|
// Notify all providers that subscription initialization is complete |
|
// |
|
for (Uint32 j = 0; j < providerList.size(); j++) |
{ | { |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
providerList[j]->subscriptionInitComplete(); |
"Exception: Unknown"); |
|
handler.setStatus(CIM_ERR_FAILED, "Unknown error."); |
|
} | } |
| |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
|
return response; |
return(response); |
|
} | } |
| |
Message * DefaultProviderManager::handleCreateInstanceRequest(const Message * message) throw() |
ProviderName DefaultProviderManager::_resolveProviderName( |
|
const ProviderIdContainer & providerId) |
{ | { |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleCreateInstanceRequest"); |
String providerName; |
|
String fileName; |
CIMCreateInstanceRequestMessage * request = |
String interfaceName; |
dynamic_cast<CIMCreateInstanceRequestMessage *>(const_cast<Message *>(message)); |
CIMValue genericValue; |
|
|
PEGASUS_ASSERT(request != 0); |
|
| |
// create response message |
genericValue = providerId.getProvider().getProperty( |
CIMCreateInstanceResponseMessage * response = |
providerId.getProvider().findProperty("Name")).getValue(); |
new CIMCreateInstanceResponseMessage( |
genericValue.get(providerName); |
request->messageId, |
|
CIMException(), |
|
request->queueIds.copyAndPop(), |
|
CIMObjectPath()); |
|
| |
PEGASUS_ASSERT(response != 0); |
genericValue = providerId.getModule().getProperty( |
|
providerId.getModule().findProperty("Location")).getValue(); |
// preserve message key |
genericValue.get(fileName); |
response->setKey(request->getKey()); |
fileName = _resolvePhysicalName(fileName); |
| |
// Set HTTP method in response from request |
// ATTN: This attribute is probably not required |
response->setHttpMethod (request->getHttpMethod ()); |
genericValue = providerId.getModule().getProperty( |
|
providerId.getModule().findProperty("InterfaceType")).getValue(); |
|
genericValue.get(interfaceName); |
| |
// create a handler for this request |
return ProviderName(providerName, fileName, interfaceName, 0); |
CreateInstanceResponseHandler handler(request, response); |
} |
| |
try |
ProviderOperationCounter DefaultProviderManager::_getProvider( |
|
const String& moduleFileName, |
|
const String& providerName) |
{ | { |
Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, |
"DefaultProviderManager::handleCreateInstanceRequest - Host name: $0 Name space: $1 Class name: $2", |
"DefaultProviderManager::_getProvider"); |
System::getHostName(), |
|
request->nameSpace.getString(), |
|
request->newInstance.getPath().getClassName().getString()); |
|
|
|
// make target object path |
|
CIMObjectPath objectPath( |
|
System::getHostName(), |
|
request->nameSpace, |
|
request->newInstance.getPath().getClassName(), |
|
request->newInstance.getPath().getKeyBindings()); |
|
|
|
InternalProviderName name( |
|
String::EMPTY, |
|
String::EMPTY, |
|
objectPath.toString()); |
|
| |
name = findProvider(name.toString()); |
ProviderMessageHandler* pr = _lookupProvider(providerName); |
| |
// get cached or load new provider module |
if (!pr->status.isInitialized()) |
OpProviderHolder ph = |
{ |
providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY); |
_initProvider(pr, moduleFileName); |
| |
// convert arguments |
if (!pr->status.isInitialized()) |
OperationContext context; |
{ |
|
PEG_METHOD_EXIT(); |
|
throw PEGASUS_CIM_EXCEPTION( |
|
CIM_ERR_FAILED, "provider initialization failed"); |
|
} |
|
} |
| |
context.insert(IdentityContainer(request->userName)); |
ProviderOperationCounter poc(pr); |
context.insert(AcceptLanguageListContainer(request->acceptLanguages)); |
poc.GetProvider().status.update_idle_timer(); |
context.insert(ContentLanguageListContainer(request->contentLanguages)); |
|
| |
// forward request |
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, | PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
"Calling provider.createInstance: " + |
"Returning Provider " + providerName); |
ph.GetProvider().getName()); |
|
| |
pm_service_op_lock op_lock(&ph.GetProvider()); |
PEG_METHOD_EXIT(); |
|
return poc; |
|
} |
| |
STAT_GETSTARTTIME; |
ProviderMessageHandler* DefaultProviderManager::_lookupProvider( |
|
const String& providerName) |
|
{ |
|
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, |
|
"DefaultProviderManager::_lookupProvider"); |
| |
ph.GetProvider().createInstance( |
// lock the providerTable mutex |
context, |
AutoMutex lock(_providerTableMutex); |
objectPath, |
|
request->newInstance, |
|
handler); |
|
| |
STAT_PMS_PROVIDEREND; |
// look up provider in cache |
} |
ProviderMessageHandler* pr = 0; |
catch(CIMException & e) |
if (_providers.lookup(providerName, pr)) |
{ |
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Exception: " + e.getMessage()); |
|
handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n |
|
} |
|
catch(Exception & e) |
|
{ | { |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, | PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
"Exception: " + e.getMessage()); |
"Found Provider " + providerName + " in Provider Manager Cache"); |
handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n |
|
} | } |
catch(...) |
else |
{ | { |
|
// create provider |
|
pr = new ProviderMessageHandler( |
|
providerName, 0, _indicationCallback, _responseChunkCallback, |
|
_subscriptionInitComplete); |
|
|
|
// insert provider in provider table |
|
_providers.insert(providerName, pr); |
|
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, | PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
"Exception: Unknown"); |
"Created provider " + pr->getName()); |
handler.setStatus(CIM_ERR_FAILED, "Unknown error."); |
|
} | } |
| |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
|
return pr; |
return(response); |
|
} | } |
| |
Message * DefaultProviderManager::handleModifyInstanceRequest(const Message * message) throw() |
ProviderMessageHandler* DefaultProviderManager::_initProvider( |
|
ProviderMessageHandler* provider, |
|
const String& moduleFileName) |
{ | { |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleModifyInstanceRequest"); |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, |
|
"DefaultProviderManager::_initProvider"); |
CIMModifyInstanceRequestMessage * request = |
|
dynamic_cast<CIMModifyInstanceRequestMessage *>(const_cast<Message *>(message)); |
|
| |
PEGASUS_ASSERT(request != 0); |
ProviderModule* module = 0; |
|
CIMProvider* base; |
| |
// create response message |
{ |
CIMModifyInstanceResponseMessage * response = |
// lock the providerTable mutex |
new CIMModifyInstanceResponseMessage( |
AutoMutex lock(_providerTableMutex); |
request->messageId, |
|
CIMException(), |
|
request->queueIds.copyAndPop()); |
|
| |
PEGASUS_ASSERT(response != 0); |
// lookup provider module |
|
module = _lookupModule(moduleFileName); |
|
} // unlock the providerTable mutex |
| |
// preserve message key |
{ |
response->setKey(request->getKey()); |
// lock the provider status mutex |
|
AutoMutex lock(provider->status._statusMutex); |
| |
// Set HTTP method in response from request |
if (provider->status.isInitialized()) |
response->setHttpMethod (request->getHttpMethod ()); |
{ |
|
// Initialization is already complete |
|
return provider; |
|
} |
| |
// create a handler for this request |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
ModifyInstanceResponseHandler handler(request, response); |
"Loading/Linking Provider Module " + moduleFileName); |
| |
|
// load the provider |
try | try |
{ | { |
Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
base = module->load(provider->getName()); |
"DefaultProviderManager::handleModifyInstanceRequest - Host name: $0 Name space: $1 Class name: $2", |
} |
System::getHostName(), |
catch (...) |
request->nameSpace.getString(), |
{ |
request->modifiedInstance.getPath().getClassName().getString()); |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Exception caught Loading/Linking Provider Module " + |
// make target object path |
moduleFileName); |
CIMObjectPath objectPath( |
PEG_METHOD_EXIT(); |
System::getHostName(), |
throw; |
request->nameSpace, |
} |
request->modifiedInstance.getPath ().getClassName(), |
|
request->modifiedInstance.getPath ().getKeyBindings()); |
|
|
|
InternalProviderName name( |
|
String::EMPTY, |
|
String::EMPTY, |
|
objectPath.toString()); |
|
| |
name = findProvider(name.toString()); |
// initialize the provider |
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
|
"Initializing Provider " + provider->getName()); |
| |
// get cached or load new provider module |
CIMOMHandle *cimomHandle = new CIMOMHandle(); |
OpProviderHolder ph = |
provider->status.setCIMOMHandle(cimomHandle); |
providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY); |
provider->status.setModule(module); |
|
provider->status._quantum=0; |
|
provider->setProvider(base); |
| |
// convert arguments |
Boolean initializeError = false; |
OperationContext context; |
|
| |
context.insert(IdentityContainer(request->userName)); |
try |
context.insert(AcceptLanguageListContainer(request->acceptLanguages)); |
{ |
context.insert(ContentLanguageListContainer(request->contentLanguages)); |
provider->initialize(*(provider->status._cimom_handle)); |
|
} |
|
catch (...) |
|
{ |
|
initializeError = true; |
|
} |
| |
CIMPropertyList propertyList(request->propertyList); |
provider->status.setInitialized(!initializeError); |
|
provider->status._currentOperations = 0; |
| |
// forward request |
// The cleanup code executed when an exception occurs was previously |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
// included in the catch block above. Unloading the provider module |
"Calling provider.modifyInstance: " + |
// from inside the catch block resulted in a crash when an exception |
ph.GetProvider().getName()); |
// was thrown from a provider's initialize() method. The issue is that |
|
// when an exception is thrown, the program maintains internal |
|
// pointers related to the code that threw the exception. In the case |
|
// of an exception thrown from a provider during the initialize() |
|
// method, those pointers point into the provider library, so when |
|
// the LocalProviderManager unloads the library, the pointers into the |
|
// library that the program was holding are invalid. |
|
if (initializeError == true) |
|
{ |
|
// delete the cimom handle |
|
delete provider->status._cimom_handle; |
| |
pm_service_op_lock op_lock(&ph.GetProvider()); |
// set provider status to uninitialized |
|
provider->status.reset(); |
| |
STAT_GETSTARTTIME; |
provider->setProvider(0); |
| |
ph.GetProvider().modifyInstance( |
// unload provider module |
context, |
module->unloadModule(); |
objectPath, |
} |
request->modifiedInstance, |
} // unlock the provider status mutex |
request->includeQualifiers, |
|
propertyList, |
|
handler); |
|
| |
STAT_PMS_PROVIDEREND; |
PEG_METHOD_EXIT(); |
|
return provider; |
} | } |
catch(CIMException & e) |
|
|
ProviderModule* DefaultProviderManager::_lookupModule( |
|
const String& moduleFileName) |
{ | { |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, |
"Exception: " + e.getMessage()); |
"DefaultProviderManager::_lookupModule"); |
handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n |
|
} |
// look up provider module in cache |
catch(Exception & e) |
ProviderModule* module = 0; |
|
|
|
if (_modules.lookup(moduleFileName, module)) |
{ | { |
|
// found provider module in cache |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, | PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
"Exception: " + e.getMessage()); |
"Found Provider Module " + moduleFileName + |
handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n |
" in Provider Manager Cache"); |
} | } |
catch(...) |
else |
{ | { |
|
// provider module not found in cache, create provider module |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, | PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
"Exception: Unknown"); |
"Creating Provider Module " + moduleFileName); |
handler.setStatus(CIM_ERR_FAILED, "Unknown error."); |
|
|
module = new ProviderModule(moduleFileName); |
|
|
|
// insert provider module in module table |
|
_modules.insert(moduleFileName, module); |
} | } |
| |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
|
return module; |
return(response); |
|
} | } |
| |
Message * DefaultProviderManager::handleDeleteInstanceRequest(const Message * message) throw() |
Boolean DefaultProviderManager::hasActiveProviders() |
{ | { |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleDeleteInstanceRequest"); |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, |
|
"DefaultProviderManager::hasActiveProviders"); |
CIMDeleteInstanceRequestMessage * request = |
|
dynamic_cast<CIMDeleteInstanceRequestMessage *>(const_cast<Message *>(message)); |
|
| |
PEGASUS_ASSERT(request != 0); |
try |
|
{ |
|
AutoMutex lock(_providerTableMutex); |
|
Tracer::trace(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Number of providers in _providers table = %d", _providers.size()); |
| |
// create response message |
// Iterate through the _providers table looking for an active provider |
CIMDeleteInstanceResponseMessage * response = |
for (ProviderTable::Iterator i = _providers.start(); i != 0; i++) |
new CIMDeleteInstanceResponseMessage( |
|
request->messageId, |
|
CIMException(), |
|
request->queueIds.copyAndPop()); |
|
|
|
PEGASUS_ASSERT(response != 0); |
|
|
|
// preserve message key |
|
response->setKey(request->getKey()); |
|
|
|
// Set HTTP method in response from request |
|
response->setHttpMethod (request->getHttpMethod ()); |
|
|
|
// create a handler for this request |
|
DeleteInstanceResponseHandler handler(request, response); |
|
|
|
try |
|
{ |
|
Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
|
"DefaultProviderManager::handleDeleteInstanceRequest - Host name: $0 Name space: $1 Class name: $2", |
|
System::getHostName(), |
|
request->nameSpace.getString(), |
|
request->instanceName.getClassName().getString()); |
|
|
|
// make target object path |
|
CIMObjectPath objectPath( |
|
System::getHostName(), |
|
request->nameSpace, |
|
request->instanceName.getClassName(), |
|
request->instanceName.getKeyBindings()); |
|
|
|
InternalProviderName name( |
|
String::EMPTY, |
|
String::EMPTY, |
|
objectPath.toString()); |
|
|
|
name = findProvider(name.toString()); |
|
|
|
// get cached or load new provider module |
|
OpProviderHolder ph = |
|
providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY); |
|
|
|
// convert arguments |
|
OperationContext context; |
|
|
|
context.insert(IdentityContainer(request->userName)); |
|
context.insert(AcceptLanguageListContainer(request->acceptLanguages)); |
|
context.insert(ContentLanguageListContainer(request->contentLanguages)); |
|
|
|
// forward request |
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Calling provider.deleteInstance: " + |
|
ph.GetProvider().getName()); |
|
|
|
pm_service_op_lock op_lock(&ph.GetProvider()); |
|
|
|
STAT_GETSTARTTIME; |
|
|
|
ph.GetProvider().deleteInstance( |
|
context, |
|
objectPath, |
|
handler); |
|
|
|
STAT_PMS_PROVIDEREND; |
|
} |
|
catch(CIMException & e) |
|
{ |
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Exception: " + e.getMessage()); |
|
handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n |
|
} |
|
catch(Exception & e) |
|
{ |
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Exception: " + e.getMessage()); |
|
handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n |
|
} |
|
catch(...) |
|
{ |
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Exception: Unknown"); |
|
handler.setStatus(CIM_ERR_FAILED, "Unknown error."); |
|
} |
|
|
|
PEG_METHOD_EXIT(); |
|
|
|
return(response); |
|
} |
|
|
|
Message * DefaultProviderManager::handleExecuteQueryRequest(const Message * message) throw() |
|
{ |
|
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleExecuteQueryRequest"); |
|
|
|
CIMExecQueryRequestMessage * request = |
|
dynamic_cast<CIMExecQueryRequestMessage *>(const_cast<Message *>(message)); |
|
|
|
PEGASUS_ASSERT(request != 0); |
|
|
|
//l10n |
|
CIMExecQueryResponseMessage * response = |
|
new CIMExecQueryResponseMessage( |
|
request->messageId, |
|
PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, MessageLoaderParms( |
|
"ProviderManager.DefaultProviderManager.NOT_IMPLEMENTED", |
|
"not implemented")), |
|
request->queueIds.copyAndPop(), |
|
Array<CIMObject>()); |
|
|
|
PEGASUS_ASSERT(response != 0); |
|
|
|
// preserve message key |
|
response->setKey(request->getKey()); |
|
|
|
// Set HTTP method in response from request |
|
response->setHttpMethod(request->getHttpMethod()); |
|
|
|
// l10n |
|
// ATTN: when this is implemented, need to add the language containers to the |
|
// OperationContext. See how the other requests do it. |
|
|
|
PEG_METHOD_EXIT(); |
|
|
|
return(response); |
|
} |
|
|
|
Message * DefaultProviderManager::handleAssociatorsRequest(const Message * message) throw() |
|
{ |
|
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleAssociatorsRequest"); |
|
|
|
CIMAssociatorsRequestMessage * request = |
|
dynamic_cast<CIMAssociatorsRequestMessage *>(const_cast<Message *>(message)); |
|
|
|
PEGASUS_ASSERT(request != 0); |
|
|
|
CIMAssociatorsResponseMessage * response = |
|
new CIMAssociatorsResponseMessage( |
|
request->messageId, |
|
CIMException(), |
|
request->queueIds.copyAndPop(), |
|
Array<CIMObject>()); |
|
|
|
PEGASUS_ASSERT(response != 0); |
|
|
|
// preserve message key |
|
response->setKey(request->getKey()); |
|
|
|
// create a handler for this request |
|
AssociatorsResponseHandler handler(request, response); |
|
|
|
// process the request |
|
try |
|
{ |
|
Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
|
"DefaultProviderManager::handleAssociatorsRequest - Host name: $0 Name space: $1 Class name: $2", |
|
System::getHostName(), |
|
request->nameSpace.getString(), |
|
request->objectName.getClassName().getString()); |
|
|
|
// make target object path |
|
CIMObjectPath objectPath( |
|
System::getHostName(), |
|
request->nameSpace, |
|
request->objectName.getClassName()); |
|
|
|
objectPath.setKeyBindings(request->objectName.getKeyBindings()); |
|
|
|
// get the provider file name and logical name |
|
Array<String> first; |
|
Array<String> second; |
|
Array<String> third; |
|
|
|
/* ATTN: temp disabled by Chip |
|
getProviderRegistrar()->_lookupProviderForAssocClass(objectPath, |
|
// request->associationClass, |
|
// request->resultClass, |
|
CIMName(), |
|
CIMName(), |
|
first, second, third); |
|
*/ |
|
|
|
for(Uint32 i=0,n=first.size(); i<n; i++) |
|
{ |
|
// get cached or load new provider module |
|
OpProviderHolder ph = |
|
providerManager.getProvider(first[i], second[i], third[i]); |
|
|
|
// convert arguments |
|
OperationContext context; |
|
|
|
context.insert(IdentityContainer(request->userName)); |
|
context.insert(AcceptLanguageListContainer(request->acceptLanguages)); |
|
context.insert(ContentLanguageListContainer(request->contentLanguages)); |
|
|
|
// ATTN KS STAT_GETSTARTTIME; |
|
pm_service_op_lock op_lock(&ph.GetProvider()); |
|
|
|
ph.GetProvider().associators( |
|
context, |
|
objectPath, |
|
request->assocClass, |
|
request->resultClass, |
|
request->role, |
|
request->resultRole, |
|
request->includeQualifiers, |
|
request->includeClassOrigin, |
|
request->propertyList.getPropertyNameArray(), |
|
handler); |
|
|
|
STAT_PMS_PROVIDEREND; |
|
|
|
} // end for loop |
|
} |
|
catch(CIMException & e) |
|
{ |
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Exception: " + e.getMessage()); |
|
handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n |
|
} |
|
catch(Exception & e) |
|
{ |
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Exception: " + e.getMessage()); |
|
handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n |
|
} |
|
catch(...) |
|
{ |
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Exception: Unknown"); |
|
handler.setStatus(CIM_ERR_FAILED, "Unknown error."); |
|
} |
|
|
|
PEG_METHOD_EXIT(); |
|
|
|
return(response); |
|
} |
|
|
|
Message * DefaultProviderManager::handleAssociatorNamesRequest(const Message * message) throw() |
|
{ |
|
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleAssociatorNamesRequest"); |
|
|
|
CIMAssociatorNamesRequestMessage * request = |
|
dynamic_cast<CIMAssociatorNamesRequestMessage *>(const_cast<Message *>(message)); |
|
|
|
PEGASUS_ASSERT(request != 0); |
|
|
|
CIMAssociatorNamesResponseMessage * response = |
|
new CIMAssociatorNamesResponseMessage( |
|
request->messageId, |
|
CIMException(), |
|
request->queueIds.copyAndPop(), |
|
Array<CIMObjectPath>()); |
|
|
|
PEGASUS_ASSERT(response != 0); |
|
|
|
// preserve message key |
|
response->setKey(request->getKey()); |
|
|
|
// Set HTTP method in response from request |
|
response->setHttpMethod(request->getHttpMethod()); |
|
|
|
// create a handler for this request |
|
AssociatorNamesResponseHandler handler(request, response); |
|
|
|
// process the request |
|
try |
|
{ |
|
Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
|
"DefaultProviderManager::handleAssociationNamesRequest - Host name: $0 Name space: $1 Class name: $2", |
|
System::getHostName(), |
|
request->nameSpace.getString(), |
|
request->objectName.getClassName().getString()); |
|
|
|
// make target object path |
|
CIMObjectPath objectPath( |
|
System::getHostName(), |
|
request->nameSpace, |
|
request->objectName.getClassName()); |
|
|
|
objectPath.setKeyBindings(request->objectName.getKeyBindings()); |
|
|
|
// get the provider file name and logical name |
|
Array<String> first; |
|
Array<String> second; |
|
Array<String> third; |
|
|
|
/* temp disabled by Chip |
|
getProviderRegistrar()->_lookupProviderForAssocClass(objectPath, |
|
// request->associationClass, |
|
// request->resultClass, |
|
CIMName(), |
|
CIMName(), |
|
first, second, third); |
|
*/ |
|
|
|
for(Uint32 i=0,n=first.size(); i<n; i++) |
|
{ |
|
// get cached or load new provider module |
|
OpProviderHolder ph = |
|
providerManager.getProvider(first[i], second[i], third[i]); |
|
|
|
// convert arguments |
|
OperationContext context; |
|
|
|
context.insert(IdentityContainer(request->userName)); |
|
context.insert(AcceptLanguageListContainer(request->acceptLanguages)); |
|
context.insert(ContentLanguageListContainer(request->contentLanguages)); |
|
|
|
pm_service_op_lock op_lock(&ph.GetProvider()); |
|
|
|
ph.GetProvider().associatorNames( |
|
context, |
|
objectPath, |
|
request->assocClass, |
|
request->resultClass, |
|
request->role, |
|
request->resultRole, |
|
handler); |
|
|
|
STAT_PMS_PROVIDEREND; |
|
|
|
} // end for loop |
|
} |
|
catch(CIMException & e) |
|
{ |
|
handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n |
|
} |
|
catch(Exception & e) |
|
{ |
|
handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n |
|
} |
|
catch(...) |
|
{ |
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Exception: Unknown"); |
|
handler.setStatus(CIM_ERR_FAILED, "Unknown error."); |
|
} |
|
|
|
PEG_METHOD_EXIT(); |
|
|
|
return(response); |
|
} |
|
|
|
Message * DefaultProviderManager::handleReferencesRequest(const Message * message) throw() |
|
{ |
|
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleReferencesRequest"); |
|
|
|
CIMReferencesRequestMessage * request = |
|
dynamic_cast<CIMReferencesRequestMessage *>(const_cast<Message *>(message)); |
|
|
|
PEGASUS_ASSERT(request != 0); |
|
|
|
CIMReferencesResponseMessage * response = |
|
new CIMReferencesResponseMessage( |
|
request->messageId, |
|
CIMException(), |
|
request->queueIds.copyAndPop(), |
|
Array<CIMObject>()); |
|
|
|
PEGASUS_ASSERT(response != 0); |
|
|
|
// preserve message key |
|
response->setKey(request->getKey()); |
|
|
|
// Set HTTP method in response from request |
|
response->setHttpMethod (request->getHttpMethod ()); |
|
|
|
// create a handler for this request |
|
ReferencesResponseHandler handler(request, response); |
|
|
|
// process the request |
|
try |
|
{ |
|
Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
|
"DefaultProviderManager::handleReferencesRequest - Host name: $0 Name space: $1 Class name: $2", |
|
System::getHostName(), |
|
request->nameSpace.getString(), |
|
request->objectName.getClassName().getString()); |
|
|
|
// make target object path |
|
CIMObjectPath objectPath( |
|
System::getHostName(), |
|
request->nameSpace, |
|
request->objectName.getClassName()); |
|
|
|
objectPath.setKeyBindings(request->objectName.getKeyBindings()); |
|
|
|
// get the provider file name and logical name |
|
Array<String> first; |
|
Array<String> second; |
|
Array<String> third; |
|
|
|
/* temp disabled by Chip |
|
getProviderRegistrar()->_lookupProviderForAssocClass(objectPath, |
|
// request->associationClass, |
|
// request->resultClass, |
|
CIMName(), |
|
CIMName(), |
|
first, second, third); |
|
*/ |
|
|
|
for(Uint32 i = 0, n = first.size(); i < n; i++) |
|
{ |
|
// get cached or load new provider module |
|
//Provider provider = |
|
OpProviderHolder ph = |
|
providerManager.getProvider(first[i], second[i], third[i]); |
|
|
|
// convert arguments |
|
OperationContext context; |
|
|
|
context.insert(IdentityContainer(request->userName)); |
|
context.insert(AcceptLanguageListContainer(request->acceptLanguages)); |
|
context.insert(ContentLanguageListContainer(request->contentLanguages)); |
|
|
|
STAT_GETSTARTTIME; |
|
|
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Calling provider.references: " + |
|
ph.GetProvider().getName()); |
|
|
|
pm_service_op_lock op_lock(&ph.GetProvider()); |
|
|
|
ph.GetProvider().references( |
|
context, |
|
objectPath, |
|
request->resultClass, |
|
request->role, |
|
request->includeQualifiers, |
|
request->includeClassOrigin, |
|
request->propertyList.getPropertyNameArray(), |
|
handler); |
|
|
|
STAT_PMS_PROVIDEREND; |
|
|
|
} // end for loop |
|
} |
|
catch(CIMException & e) |
|
{ |
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Exception: " + e.getMessage()); |
|
handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n |
|
} |
|
catch(Exception & e) |
|
{ |
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Exception: " + e.getMessage()); |
|
handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n |
|
} |
|
catch(...) |
|
{ |
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Exception: Unknown"); |
|
handler.setStatus(CIM_ERR_FAILED, "Unknown error."); |
|
} |
|
|
|
PEG_METHOD_EXIT(); |
|
|
|
return(response); |
|
} |
|
|
|
Message * DefaultProviderManager::handleReferenceNamesRequest(const Message * message) throw() |
|
{ |
|
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleReferenceNamesRequest"); |
|
|
|
CIMReferenceNamesRequestMessage * request = |
|
dynamic_cast<CIMReferenceNamesRequestMessage *>(const_cast<Message *>(message)); |
|
|
|
PEGASUS_ASSERT(request != 0); |
|
|
|
CIMReferenceNamesResponseMessage * response = |
|
new CIMReferenceNamesResponseMessage( |
|
request->messageId, |
|
CIMException(), |
|
request->queueIds.copyAndPop(), |
|
Array<CIMObjectPath>()); |
|
|
|
// preserve message key |
|
response->setKey(request->getKey()); |
|
|
|
// Set HTTP method in response from request |
|
response->setHttpMethod (request->getHttpMethod ()); |
|
|
|
// create a handler for this request |
|
ReferenceNamesResponseHandler handler(request, response); |
|
|
|
// process the request |
|
try |
|
{ |
|
Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
|
"DefaultProviderManager::handleReferenceNamesRequest - Host name: $0 Name space: $1 Class name: $2", |
|
System::getHostName(), |
|
request->nameSpace.getString(), |
|
request->objectName.getClassName().getString()); |
|
|
|
// make target object path |
|
CIMObjectPath objectPath( |
|
System::getHostName(), |
|
request->nameSpace, |
|
request->objectName.getClassName()); |
|
|
|
objectPath.setKeyBindings(request->objectName.getKeyBindings()); |
|
|
|
// get the provider file name and logical name |
|
Array<String> first; |
|
Array<String> second; |
|
Array<String> third; |
|
|
|
/* temp disabled by Chip |
|
getProviderRegistrar()->_lookupProviderForAssocClass(objectPath, |
|
// request->associationClass, |
|
// request->resultClass, |
|
CIMName(), |
|
CIMName(), |
|
first, second, third); |
|
*/ |
|
|
|
for(Uint32 i=0,n=first.size(); i<n; i++) |
|
{ |
|
// get cached or load new provider module |
|
//Provider provider = |
|
OpProviderHolder ph = |
|
providerManager.getProvider(first[i], second[i], third[i]); |
|
|
|
// convert arguments |
|
OperationContext context; |
|
|
|
context.insert(IdentityContainer(request->userName)); |
|
context.insert(AcceptLanguageListContainer(request->acceptLanguages)); |
|
context.insert(ContentLanguageListContainer(request->contentLanguages)); |
|
|
|
STAT_GETSTARTTIME; |
|
|
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Calling provider.referenceNames: " + |
|
ph.GetProvider().getName()); |
|
|
|
pm_service_op_lock op_lock(&ph.GetProvider()); |
|
|
|
ph.GetProvider().referenceNames( |
|
context, |
|
objectPath, |
|
request->resultClass, |
|
request->role, |
|
handler); |
|
|
|
STAT_PMS_PROVIDEREND; |
|
|
|
} // end for loop |
|
} |
|
catch(CIMException & e) |
|
{ |
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Exception: " + e.getMessage()); |
|
handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n |
|
} |
|
catch(Exception & e) |
|
{ |
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Exception: " + e.getMessage()); |
|
handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n |
|
} |
|
catch(...) |
|
{ |
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Exception: Unknown"); |
|
handler.setStatus(CIM_ERR_FAILED, "Unknown error."); |
|
} |
|
|
|
PEG_METHOD_EXIT(); |
|
|
|
return(response); |
|
} |
|
|
|
Message * DefaultProviderManager::handleGetPropertyRequest(const Message * message) throw() |
|
{ |
|
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleGetPropertyRequest"); |
|
|
|
CIMGetPropertyRequestMessage * request = |
|
dynamic_cast<CIMGetPropertyRequestMessage *>(const_cast<Message *>(message)); |
|
|
|
PEGASUS_ASSERT(request != 0); |
|
|
|
// create response message |
|
CIMGetPropertyResponseMessage * response = |
|
new CIMGetPropertyResponseMessage( |
|
request->messageId, |
|
CIMException(), |
|
request->queueIds.copyAndPop(), |
|
CIMValue()); |
|
|
|
PEGASUS_ASSERT(response != 0); |
|
|
|
// preserve message key |
|
response->setKey(request->getKey()); |
|
|
|
// Set HTTP method in response from request |
|
response->setHttpMethod(request->getHttpMethod()); |
|
|
|
GetPropertyResponseHandler handler(request, response); |
|
|
|
try |
|
{ |
|
Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
|
"DefaultProviderManager::handleGetPropertyRequest - Host name: $0 Name space: $1 Class name: $2", |
|
System::getHostName(), |
|
request->nameSpace.getString(), |
|
request->instanceName.getClassName().getString()); |
|
|
|
// make target object path |
|
CIMObjectPath objectPath( |
|
System::getHostName(), |
|
request->nameSpace, |
|
request->instanceName.getClassName(), |
|
request->instanceName.getKeyBindings()); |
|
|
|
InternalProviderName name( |
|
String::EMPTY, |
|
String::EMPTY, |
|
objectPath.toString()); |
|
|
|
name = findProvider(name.toString()); |
|
|
|
// get cached or load new provider module |
|
OpProviderHolder ph = |
|
providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY); |
|
|
|
// convert arguments |
|
OperationContext context; |
|
|
|
context.insert(IdentityContainer(request->userName)); |
|
context.insert(AcceptLanguageListContainer(request->acceptLanguages)); |
|
context.insert(ContentLanguageListContainer(request->contentLanguages)); |
|
|
|
CIMName propertyName = request->propertyName; |
|
|
|
STAT_GETSTARTTIME; |
|
|
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Calling provider.getProperty: " + |
|
ph.GetProvider().getName()); |
|
|
|
// forward request |
|
pm_service_op_lock op_lock(&ph.GetProvider()); |
|
|
|
ph.GetProvider().getProperty( |
|
context, |
|
objectPath, |
|
propertyName, |
|
handler); |
|
|
|
STAT_PMS_PROVIDEREND; |
|
} |
|
catch(CIMException & e) |
|
{ |
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Exception: " + e.getMessage()); |
|
handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n |
|
} |
|
catch(Exception & e) |
|
{ |
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Exception: " + e.getMessage()); |
|
handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n |
|
} |
|
catch(...) |
|
{ |
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Exception: Unknown"); |
|
handler.setStatus(CIM_ERR_FAILED, "Unknown error."); |
|
} |
|
|
|
PEG_METHOD_EXIT(); |
|
|
|
return(response); |
|
} |
|
|
|
Message * DefaultProviderManager::handleSetPropertyRequest(const Message * message) throw() |
|
{ |
|
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleSetPropertyRequest"); |
|
|
|
CIMSetPropertyRequestMessage * request = |
|
dynamic_cast<CIMSetPropertyRequestMessage *>(const_cast<Message *>(message)); |
|
|
|
PEGASUS_ASSERT(request != 0); |
|
|
|
// create response message |
|
//l10n |
|
CIMSetPropertyResponseMessage * response = |
|
new CIMSetPropertyResponseMessage( |
|
request->messageId, |
|
PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, MessageLoaderParms( |
|
"ProviderManager.DefaultProviderManager.NOT_IMPLEMENTED", |
|
"not implemented")), |
|
request->queueIds.copyAndPop()); |
|
|
|
PEGASUS_ASSERT(response != 0); |
|
|
|
// preserve message key |
|
response->setKey(request->getKey()); |
|
|
|
// Set HTTP method in response from request |
|
response->setHttpMethod(request->getHttpMethod()); |
|
|
|
SetPropertyResponseHandler handler(request, response); |
|
|
|
try |
|
{ |
|
Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
|
"DefaultProviderManager::handleSetPropertyRequest - Host name: $0 Name space: $1 Class name: $2", |
|
System::getHostName(), |
|
request->nameSpace.getString(), |
|
request->instanceName.getClassName().getString()); |
|
|
|
// make target object path |
|
CIMObjectPath objectPath( |
|
System::getHostName(), |
|
request->nameSpace, |
|
request->instanceName.getClassName(), |
|
request->instanceName.getKeyBindings()); |
|
|
|
InternalProviderName name( |
|
String::EMPTY, |
|
String::EMPTY, |
|
objectPath.toString()); |
|
|
|
name = findProvider(name.toString()); |
|
|
|
// get cached or load new provider module |
|
OpProviderHolder ph = |
|
providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY); |
|
|
|
// convert arguments |
|
OperationContext context; |
|
|
|
context.insert(IdentityContainer(request->userName)); |
|
context.insert(AcceptLanguageListContainer(request->acceptLanguages)); |
|
context.insert(ContentLanguageListContainer(request->contentLanguages)); |
|
|
|
CIMName propertyName = request->propertyName; |
|
CIMValue propertyValue = request->newValue; |
|
|
|
STAT_GETSTARTTIME; |
|
|
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Calling provider.setProperty: " + |
|
ph.GetProvider().getName()); |
|
|
|
// forward request |
|
pm_service_op_lock op_lock(&ph.GetProvider()); |
|
|
|
ph.GetProvider().setProperty( |
|
context, |
|
objectPath, |
|
propertyName, |
|
propertyValue, |
|
handler); |
|
|
|
STAT_PMS_PROVIDEREND; |
|
} |
|
catch(CIMException & e) |
|
{ |
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Exception: " + e.getMessage()); |
|
handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n |
|
} |
|
catch(Exception & e) |
|
{ |
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Exception: " + e.getMessage()); |
|
handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n |
|
} |
|
catch(...) |
|
{ |
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Exception: Unknown"); |
|
handler.setStatus(CIM_ERR_FAILED, "Unknown error."); |
|
} |
|
|
|
PEG_METHOD_EXIT(); |
|
|
|
return(response); |
|
} |
|
|
|
Message * DefaultProviderManager::handleInvokeMethodRequest(const Message * message) throw() |
|
{ |
|
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleInvokeMethodRequest"); |
|
|
|
CIMInvokeMethodRequestMessage * request = |
|
dynamic_cast<CIMInvokeMethodRequestMessage *>(const_cast<Message *>(message)); |
|
|
|
PEGASUS_ASSERT(request != 0); |
|
|
|
// create response message |
|
CIMInvokeMethodResponseMessage * response = |
|
new CIMInvokeMethodResponseMessage( |
|
request->messageId, |
|
CIMException(), |
|
request->queueIds.copyAndPop(), |
|
CIMValue(), |
|
Array<CIMParamValue>(), |
|
request->methodName); |
|
|
|
PEGASUS_ASSERT(response != 0); |
|
|
|
// propagate message key |
|
response->setKey(request->getKey()); |
|
|
|
// Set HTTP method in response from request |
|
response->setHttpMethod (request->getHttpMethod ()); |
|
|
|
// create a handler for this request |
|
InvokeMethodResponseHandler handler(request, response); |
|
|
|
try |
|
{ |
|
Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
|
"DefaultProviderManager::handleInvokeMethodRequest - Host name: $0 Name space: $1 Class name: $2", |
|
System::getHostName(), |
|
request->nameSpace.getString(), |
|
request->instanceName.getClassName().getString()); |
|
|
|
// make target object path |
|
CIMObjectPath objectPath( |
|
System::getHostName(), |
|
request->nameSpace, |
|
request->instanceName.getClassName(), |
|
request->instanceName.getKeyBindings()); |
|
|
|
InternalProviderName name( |
|
String::EMPTY, |
|
String::EMPTY, |
|
objectPath.toString()); |
|
|
|
name = findProvider(name.toString()); |
|
|
|
// get cached or load new provider module |
|
OpProviderHolder ph = |
|
providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY); |
|
|
|
/* |
|
// get the provider file name and logical name |
|
Triad<String, String, String> triad = |
|
getProviderRegistrar()->_lookupMethodProviderForClass(objectPath, request->methodName); |
|
|
|
// get cached or load new provider module |
|
//Provider provider = |
|
OpProviderHolder ph = |
|
providerManager.getProvider(triad.first, triad.second, triad.third); |
|
*/ |
|
|
|
// convert arguments |
|
OperationContext context; |
|
|
|
context.insert(IdentityContainer(request->userName)); |
|
context.insert(AcceptLanguageListContainer(request->acceptLanguages)); |
|
context.insert(ContentLanguageListContainer(request->contentLanguages)); |
|
|
|
CIMObjectPath instanceReference(request->instanceName); |
|
|
|
// ATTN: propagate namespace |
|
instanceReference.setNameSpace(request->nameSpace); |
|
|
|
// forward request |
|
STAT_GETSTARTTIME; |
|
|
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Calling provider.invokeMethod: " + |
|
ph.GetProvider().getName()); |
|
|
|
pm_service_op_lock op_lock(&ph.GetProvider()); |
|
|
|
ph.GetProvider().invokeMethod( |
|
context, |
|
instanceReference, |
|
request->methodName, |
|
request->inParameters, |
|
handler); |
|
|
|
STAT_PMS_PROVIDEREND; |
|
} |
|
catch(CIMException & e) |
|
{ |
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Exception: " + e.getMessage()); |
|
handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n |
|
} |
|
catch(Exception & e) |
|
{ |
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Exception: " + e.getMessage()); |
|
handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n |
|
} |
|
catch(...) |
|
{ |
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Exception: Unknown"); |
|
handler.setStatus(CIM_ERR_FAILED, "Unknown error."); |
|
} |
|
|
|
PEG_METHOD_EXIT(); |
|
|
|
return(response); |
|
} |
|
|
|
Message * DefaultProviderManager::handleCreateSubscriptionRequest(const Message * message) throw() |
|
{ |
|
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleCreateSubscriptionRequest"); |
|
|
|
CIMCreateSubscriptionRequestMessage * request = |
|
dynamic_cast<CIMCreateSubscriptionRequestMessage *>(const_cast<Message *>(message)); |
|
|
|
PEGASUS_ASSERT(request != 0); |
|
|
|
CIMCreateSubscriptionResponseMessage * response = |
|
new CIMCreateSubscriptionResponseMessage( |
|
request->messageId, |
|
CIMException(), |
|
request->queueIds.copyAndPop()); |
|
|
|
PEGASUS_ASSERT(response != 0); |
|
|
|
// preserve message key |
|
response->setKey(request->getKey()); |
|
|
|
// Set HTTP method in response from request |
|
response->setHttpMethod (request->getHttpMethod ()); |
|
|
|
OperationResponseHandler handler(request, response); |
|
|
|
try |
|
{ |
|
InternalProviderName name(""); |
|
|
|
/* temp disabled by Chip |
|
InternalProviderName name( |
|
String::EMPTY, |
|
String::EMPTY, |
|
objectPath.toString()); |
|
|
|
name = findProvider(name.toString()); |
|
*/ |
|
|
|
// get cached or load new provider module |
|
OpProviderHolder ph = |
|
providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY); |
|
|
|
/* |
|
// get the provider file name and logical name |
|
Triad<String, String, String> triad = |
|
getProviderRegistrar()->_getProviderRegPair(request->provider, request->providerModule); |
|
|
|
// get cached or load new provider module |
|
OpProviderHolder ph = |
|
providerManager.getProvider(triad.first, triad.second, triad.third); |
|
*/ |
|
|
|
// convert arguments |
|
OperationContext context; |
|
|
|
context.insert(IdentityContainer(request->userName)); |
|
context.insert(SubscriptionInstanceContainer |
|
(request->subscriptionInstance)); |
|
context.insert(SubscriptionFilterConditionContainer |
|
(request->condition, request->queryLanguage)); |
|
context.insert(SubscriptionLanguageListContainer |
|
(request->acceptLanguages)); |
|
context.insert(AcceptLanguageListContainer(request->acceptLanguages)); |
|
context.insert(ContentLanguageListContainer(request->contentLanguages)); |
|
|
|
CIMObjectPath subscriptionName = request->subscriptionInstance.getPath(); |
|
|
|
Array<CIMObjectPath> classNames; |
|
|
|
for(Uint32 i = 0, n = request->classNames.size(); i < n; i++) |
|
{ |
|
CIMObjectPath className( |
|
System::getHostName(), |
|
request->nameSpace, |
|
request->classNames[i]); |
|
|
|
Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
|
"DefaultProviderManager::handleGetInstanceRequest - Host name: $0 Name space: $1 Class name: $2", |
|
System::getHostName(), |
|
request->nameSpace.getString(), |
|
className.toString()); |
|
|
|
classNames.append(className); |
|
} |
|
|
|
CIMPropertyList propertyList = request->propertyList; |
|
|
|
Uint16 repeatNotificationPolicy = request->repeatNotificationPolicy; |
|
|
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Calling provider.createSubscription: " + |
|
ph.GetProvider().getName()); |
|
|
|
pm_service_op_lock op_lock(&ph.GetProvider()); |
|
|
|
ph.GetProvider().createSubscription( |
|
context, |
|
subscriptionName, |
|
classNames, |
|
propertyList, |
|
repeatNotificationPolicy); |
|
} |
|
catch(CIMException & e) |
|
{ |
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Exception: " + e.getMessage()); |
|
handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n |
|
} |
|
catch(Exception & e) |
|
{ |
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Exception: " + e.getMessage()); |
|
handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n |
|
} |
|
catch(...) |
|
{ |
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Exception: Unknown"); |
|
handler.setStatus(CIM_ERR_FAILED, "Unknown Error"); |
|
} |
|
|
|
PEG_METHOD_EXIT(); |
|
|
|
return(response); |
|
} |
|
|
|
Message * DefaultProviderManager::handleModifySubscriptionRequest( const Message * message) throw() |
|
{ |
|
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleModifySubscriptionRequest"); |
|
|
|
CIMModifySubscriptionRequestMessage * request = |
|
dynamic_cast<CIMModifySubscriptionRequestMessage *>(const_cast<Message *>(message)); |
|
|
|
PEGASUS_ASSERT(request != 0); |
|
|
|
CIMModifySubscriptionResponseMessage * response = |
|
new CIMModifySubscriptionResponseMessage( |
|
request->messageId, |
|
CIMException(), |
|
request->queueIds.copyAndPop()); |
|
|
|
PEGASUS_ASSERT(response != 0); |
|
|
|
// preserve message key |
|
response->setKey(request->getKey()); |
|
|
|
// Set HTTP method in response from request |
|
response->setHttpMethod (request->getHttpMethod ()); |
|
|
|
OperationResponseHandler handler(request, response); |
|
|
|
try |
|
{ |
|
InternalProviderName name(""); |
|
|
|
/* |
|
InternalProviderName name( |
|
String::EMPTY, |
|
String::EMPTY, |
|
objectPath.toString()); |
|
|
|
name = findProvider(name.toString()); |
|
*/ |
|
|
|
// get cached or load new provider module |
|
OpProviderHolder ph = |
|
providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY); |
|
|
|
/* |
|
// get the provider file name and logical name |
|
Triad<String, String, String> triad = |
|
getProviderRegistrar()->_getProviderRegPair(request->provider, request->providerModule); |
|
|
|
// get cached or load new provider module |
|
//Provider provider = |
|
OpProviderHolder ph = |
|
providerManager.getProvider(triad.first, triad.second, triad.third); |
|
*/ |
|
|
|
// convert arguments |
|
OperationContext context; |
|
|
|
context.insert(IdentityContainer(request->userName)); |
|
|
|
context.insert(SubscriptionInstanceContainer |
|
(request->subscriptionInstance)); |
|
context.insert(SubscriptionFilterConditionContainer |
|
(request->condition, request->queryLanguage)); |
|
context.insert(SubscriptionLanguageListContainer |
|
(request->acceptLanguages)); |
|
context.insert(AcceptLanguageListContainer(request->acceptLanguages)); |
|
context.insert(ContentLanguageListContainer(request->contentLanguages)); |
|
|
|
CIMObjectPath subscriptionName = request->subscriptionInstance.getPath(); |
|
|
|
Array<CIMObjectPath> classNames; |
|
|
|
for(Uint32 i = 0, n = request->classNames.size(); i < n; i++) |
|
{ |
|
CIMObjectPath className( |
|
System::getHostName(), |
|
request->nameSpace, |
|
request->classNames[i]); |
|
|
|
Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
|
"DefaultProviderManager::handleGetInstanceRequest - Host name: $0 Name space: $1 Class name: $2", |
|
System::getHostName(), |
|
request->nameSpace.getString(), |
|
className.toString()); |
|
|
|
classNames.append(className); |
|
} |
|
|
|
CIMPropertyList propertyList = request->propertyList; |
|
|
|
Uint16 repeatNotificationPolicy = request->repeatNotificationPolicy; |
|
|
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Calling provider.modifySubscription: " + |
|
ph.GetProvider().getName()); |
|
|
|
pm_service_op_lock op_lock(&ph.GetProvider()); |
|
|
|
ph.GetProvider().modifySubscription( |
|
context, |
|
subscriptionName, |
|
classNames, |
|
propertyList, |
|
repeatNotificationPolicy); |
|
} |
|
catch(CIMException & e) |
|
{ |
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Exception: " + e.getMessage()); |
|
handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n |
|
} |
|
catch(Exception & e) |
|
{ |
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Exception: " + e.getMessage()); |
|
handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n |
|
} |
|
catch(...) |
|
{ |
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Exception: Unknown"); |
|
handler.setStatus(CIM_ERR_FAILED, "Unknown Error"); |
|
} |
|
|
|
PEG_METHOD_EXIT(); |
|
|
|
return(response); |
|
} |
|
|
|
Message * DefaultProviderManager::handleDeleteSubscriptionRequest(const Message * message) throw() |
|
{ |
|
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleDeleteSubscriptionRequest"); |
|
|
|
CIMDeleteSubscriptionRequestMessage * request = |
|
dynamic_cast<CIMDeleteSubscriptionRequestMessage *>(const_cast<Message *>(message)); |
|
|
|
PEGASUS_ASSERT(request != 0); |
|
|
|
CIMDeleteSubscriptionResponseMessage * response = |
|
new CIMDeleteSubscriptionResponseMessage( |
|
request->messageId, |
|
CIMException(), |
|
request->queueIds.copyAndPop()); |
|
|
|
PEGASUS_ASSERT(response != 0); |
|
|
|
// preserve message key |
|
response->setKey(request->getKey()); |
|
|
|
// Set HTTP method in response from request |
|
response->setHttpMethod(request->getHttpMethod()); |
|
|
|
OperationResponseHandler handler(request, response); |
|
|
|
try |
|
{ |
|
InternalProviderName name(""); |
|
|
|
/* |
|
InternalProviderName name( |
|
String::EMPTY, |
|
String::EMPTY, |
|
objectPath.toString()); |
|
|
|
name = findProvider(name.toString()); |
|
*/ |
|
|
|
// get cached or load new provider module |
|
OpProviderHolder ph = |
|
providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY); |
|
|
|
/* |
|
// get the provider file name and logical name |
|
Triad<String, String, String> triad = |
|
getProviderRegistrar()->_getProviderRegPair(request->provider, request->providerModule); |
|
|
|
// get cached or load new provider module |
|
//Provider provider = |
|
OpProviderHolder ph = |
|
providerManager.getProvider(triad.first, triad.second, triad.third); |
|
*/ |
|
|
|
// convert arguments |
|
OperationContext context; |
|
|
|
context.insert(IdentityContainer(request->userName)); |
|
context.insert(SubscriptionInstanceContainer |
|
(request->subscriptionInstance)); |
|
context.insert(SubscriptionLanguageListContainer |
|
(request->acceptLanguages)); |
|
context.insert(AcceptLanguageListContainer(request->acceptLanguages)); |
|
context.insert(ContentLanguageListContainer(request->contentLanguages)); |
|
|
|
CIMObjectPath subscriptionName = request->subscriptionInstance.getPath(); |
|
|
|
Array<CIMObjectPath> classNames; |
|
|
|
for(Uint32 i = 0, n = request->classNames.size(); i < n; i++) |
|
{ |
|
CIMObjectPath className( |
|
System::getHostName(), |
|
request->nameSpace, |
|
request->classNames[i]); |
|
|
|
Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
|
"DefaultProviderManager::handleGetInstanceRequest - Host name: $0 Name space: $1 Class name: $2", |
|
System::getHostName(), |
|
request->nameSpace.getString(), |
|
className.toString()); |
|
|
|
classNames.append(className); |
|
} |
|
|
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Calling provider.deleteSubscription: " + |
|
ph.GetProvider().getName()); |
|
|
|
pm_service_op_lock op_lock(&ph.GetProvider()); |
|
|
|
ph.GetProvider().deleteSubscription( |
|
context, |
|
subscriptionName, |
|
classNames); |
|
} |
|
catch(CIMException & e) |
|
{ | { |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
if (i.value()->status.isInitialized()) |
"Exception: " + e.getMessage()); |
|
handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n |
|
} |
|
catch(Exception & e) |
|
{ | { |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
PEG_METHOD_EXIT(); |
"Exception: " + e.getMessage()); |
return true; |
handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n |
} |
|
} |
} | } |
catch(...) | catch(...) |
{ | { |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
// Unexpected exception; do not assume that no providers are loaded |
"Exception: Unknown"); |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
handler.setStatus(CIM_ERR_FAILED, "Unknown Error"); |
"Unexpected Exception in hasActiveProviders."); |
|
PEG_METHOD_EXIT(); |
|
return true; |
} | } |
| |
|
// No active providers were found in the _providers table |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
|
return false; |
return(response); |
|
} | } |
| |
Message * DefaultProviderManager::handleEnableIndicationsRequest(const Message * message) throw() |
void DefaultProviderManager::unloadIdleProviders() |
{ | { |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager:: handleEnableIndicationsRequest"); |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, |
|
"LocalProviderManager::unloadIdleProviders"); |
CIMEnableIndicationsRequestMessage * request = |
|
dynamic_cast<CIMEnableIndicationsRequestMessage *>(const_cast<Message *>(message)); |
|
|
|
PEGASUS_ASSERT(request != 0); |
|
|
|
CIMEnableIndicationsResponseMessage * response = |
|
new CIMEnableIndicationsResponseMessage( |
|
request->messageId, |
|
CIMException(), |
|
request->queueIds.copyAndPop()); |
|
|
|
CIMEnableIndicationsResponseMessage * responseforhandler = |
|
new CIMEnableIndicationsResponseMessage( |
|
request->messageId, |
|
CIMException(), |
|
request->queueIds.copyAndPop()); |
|
| |
PEGASUS_ASSERT(response != 0); |
static Uint32 quantum = 0; |
|
static struct timeval first = {0,0}, now, last = {0,0}; |
| |
// preserve message key |
if (first.tv_sec == 0) |
response->setKey(request->getKey()); |
{ |
|
Time::gettimeofday(&first); |
|
} |
|
Time::gettimeofday(&now); |
| |
// Set HTTP method in response from request |
if (!(((now.tv_sec - first.tv_sec) > IDLE_LIMIT) && |
response->setHttpMethod(request->getHttpMethod()); |
((now.tv_sec - last.tv_sec) > IDLE_LIMIT))) |
|
{ |
|
// It's not time yet to check for idle providers |
|
PEG_METHOD_EXIT(); |
|
return; |
|
} |
| |
response->dest = request->queueIds.top(); |
Time::gettimeofday(&last); |
| |
/* |
Time::gettimeofday(&last); |
// ATTN: need pointer to Provider Manager Server! |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
//EnableIndicationsResponseHandler *handler = |
"Checking for Idle providers to unload."); |
// new EnableIndicationsResponseHandler(request, response, this); |
|
| |
try | try |
{ | { |
// get the provider file name and logical name |
AutoMutex lock(_providerTableMutex); |
Triad<String, String, String> triad = |
|
_getProviderRegPair(request->provider, request->providerModule); |
|
|
|
// get cached or load new provider module |
|
//Provider provider = |
|
OpProviderHolder ph = |
|
providerManager.getProvider(triad.first, triad.second, triad.third); |
|
| |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
quantum++; |
"Calling provider.enableIndications: " + |
|
ph.GetProvider().getName()); |
|
ph.GetProvider().protect(); |
|
ph.GetProvider().enableIndications(*handler); |
|
| |
|
struct timeval now; |
|
Time::gettimeofday(&now); |
| |
// if no exception, store the handler so it is persistent for as |
for (ProviderTable::Iterator i = _providers.start(); i != 0 ; i++) |
// long as the provider has indications enabled. |
{ |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
ProviderMessageHandler* provider = i.value(); |
"Storing indication handler for " + ph.GetProvider().getName()); |
PEGASUS_ASSERT(provider != 0); |
| |
_insertEntry(ph.GetProvider(), handler); |
if (!provider->status.isInitialized()) |
} |
|
catch(CIMException & e) |
|
{ | { |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
continue; |
"Exception: " + e.getMessage()); |
|
response->cimException = CIMException(e); |
|
} | } |
catch(Exception & e) |
|
|
if (provider->status._quantum == quantum) |
{ | { |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
continue; |
"Exception: " + e.getMessage()); |
|
//l10n |
|
//response->cimException = CIMException(CIM_ERR_FAILED, "Internal Error"); |
|
response->cimException = CIMException(CIM_ERR_FAILED, MessageLoaderParms( |
|
"ProviderManager.DefaultProviderManager.INTERNAL_ERROR", |
|
"Internal Error")); |
|
} | } |
catch(...) |
|
|
provider->status._quantum = quantum; |
|
|
|
if (provider->status._currentOperations.get()) |
{ | { |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, | PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
"Exception: Unknown"); |
"Provider has pending operations: " + |
//l10n |
provider->getName()); |
//response->cimException = CIMException(CIM_ERR_FAILED, "Unknown Error"); |
continue; |
response->cimException = CIMException(CIM_ERR_FAILED, MessageLoaderParms( |
|
"ProviderManager.DefaultProviderManager.UNKNOWN_ERROR", |
|
"Unknown Error")); |
|
} | } |
*/ |
|
| |
PEG_METHOD_EXIT(); |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Checking timeout data for Provider: " + |
|
provider->getName()); |
|
struct timeval timeout = {0,0}; |
|
provider->status.get_idle_timer(&timeout); |
| |
return(response); |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
} |
"provider->status.unload_ok() returns: " + |
|
provider->status.unload_ok() ? "true" : "false"); |
| |
Message * DefaultProviderManager::handleDisableIndicationsRequest(const Message * message) throw() |
if (provider->status.unload_ok() && |
|
((now.tv_sec - timeout.tv_sec) > ((Sint32)IDLE_LIMIT))) |
{ | { |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleDisableIndicationsRequest"); |
AutoMutex pr_lock(provider->status._statusMutex); |
|
Logger::put( |
CIMDisableIndicationsRequestMessage * request = |
Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
dynamic_cast<CIMDisableIndicationsRequestMessage *>(const_cast<Message *>(message)); |
"LocalProviderManager::unloadIdleProviders - " |
|
"Unload idle provider $0", provider->getName()); |
PEGASUS_ASSERT(request != 0); |
|
|
|
CIMDisableIndicationsResponseMessage * response = |
|
new CIMDisableIndicationsResponseMessage( |
|
request->messageId, |
|
CIMException(), |
|
request->queueIds.copyAndPop()); |
|
|
|
PEGASUS_ASSERT(response != 0); |
|
|
|
// preserve message key |
|
response->setKey(request->getKey()); |
|
|
|
// Set HTTP method in response from request |
|
response->setHttpMethod (request->getHttpMethod ()); |
|
|
|
OperationResponseHandler handler(request, response); |
|
| |
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Trying to Terminate Provider " + provider->getName()); |
try | try |
{ | { |
InternalProviderName name(""); |
if (!provider->status.unload_ok()) |
|
{ |
/* |
|
InternalProviderName name( |
|
String::EMPTY, |
|
String::EMPTY, |
|
objectPath.toString()); |
|
|
|
name = findProvider(name.toString()); |
|
*/ |
|
|
|
// get cached or load new provider module |
|
OpProviderHolder ph = |
|
providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY); |
|
|
|
/* |
|
// get the provider file name and logical name |
|
Triad<String, String, String> triad = |
|
getProviderRegistrar()->_getProviderRegPair(request->provider, request->providerModule); |
|
|
|
// get cached or load new provider module |
|
//Provider provider = |
|
OpProviderHolder ph = |
|
providerManager.getProvider(triad.first, triad.second, triad.third); |
|
*/ |
|
|
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, | PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
"Calling provider.disableIndications: " + |
"Provider not OK to unload: " + |
ph.GetProvider().getName()); |
provider->getName()); |
|
continue; |
ph.GetProvider().disableIndications(); |
} |
| |
ph.GetProvider().unprotect(); |
provider->terminate(); |
| |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, | PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
"Removing and Destroying indication handler for " + |
"Provider terminated: " + provider->getName()); |
ph.GetProvider().getName()); |
provider->status.setInitialized(false); |
|
|
delete _removeEntry(_generateKey(ph.GetProvider())); |
|
} | } |
|
catch (...) |
catch(CIMException & e) |
|
{ | { |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, | PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
"Exception: " + e.getMessage()); |
"Exception terminating " + provider->getName()); |
response->cimException = CIMException(e); |
i = _providers.start(); |
|
continue; |
} | } |
catch(Exception & e) |
|
{ |
PEGASUS_ASSERT(provider->status._module != 0); |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, | PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
"Exception: " + e.getMessage()); |
"unloading Provider module" + provider->getName()); |
//l10n |
provider->status._module->unloadModule(); |
//response->cimException = CIMException(CIM_ERR_FAILED, "Internal Error"); |
|
response->cimException = CIMException(CIM_ERR_FAILED, MessageLoaderParms( |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
"ProviderManager.DefaultProviderManager.INTERNAL_ERROR", |
"Destroying Provider's CIMOM Handle: " + |
"Internal Error")); |
provider->getName()); |
|
delete provider->status._cimom_handle; |
|
|
|
provider->status.reset(); |
|
} |
|
} |
} | } |
catch(...) | catch(...) |
{ | { |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
"Exception: Unknown"); |
"Caught unexpected exception in unloadIdleProviders."); |
//l10n |
|
//response->cimException = CIMException(CIM_ERR_FAILED, "Unknown Error"); |
|
response->cimException = CIMException(CIM_ERR_FAILED, MessageLoaderParms( |
|
"ProviderManager.DefaultProviderManager.UNKNOWN_ERROR", |
|
"Unknown Error")); |
|
} | } |
| |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
|
|
return(response); |
|
} | } |
| |
Message * DefaultProviderManager::handleConsumeIndicationRequest(const Message *message) throw() |
void DefaultProviderManager::_shutdownAllProviders() |
{ | { |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handlConsumeIndicationRequest"); |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, |
|
"DefaultProviderManager::_shutdownAllProviders"); |
CIMConsumeIndicationRequestMessage *request = |
|
dynamic_cast<CIMConsumeIndicationRequestMessage *>(const_cast<Message *>(message)); |
|
|
|
PEGASUS_ASSERT(request != 0); |
|
|
|
CIMResponseMessage * response = |
|
new CIMResponseMessage( |
|
CIM_CONSUME_INDICATION_RESPONSE_MESSAGE, |
|
request->messageId, |
|
CIMException(), |
|
request->queueIds.copyAndPop()); |
|
|
|
PEGASUS_ASSERT(response != 0); |
|
|
|
response->setKey(request->getKey()); |
|
|
|
// Set HTTP method in response from request |
|
response->setHttpMethod (request->getHttpMethod ()); |
|
|
|
Uint32 type = 3; |
|
| |
try | try |
{ | { |
InternalProviderName name(""); |
AutoMutex lock(_providerTableMutex); |
|
|
/* |
|
InternalProviderName name( |
|
String::EMPTY, |
|
String::EMPTY, |
|
objectPath.toString()); |
|
|
|
name = findProvider(name.toString()); |
|
*/ |
|
|
|
// get cached or load new provider module |
|
OpProviderHolder ph = |
|
providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY); |
|
| |
/* |
Tracer::trace(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
// get the provider file name and logical name |
"providers in cache = %d", _providers.size()); |
Triad<String, String, String> triad = |
|
getProviderRegistrar()->_getProviderRegPair(request->consumer_provider, request->consumer_module); |
|
| |
// get cached or load new provider module |
for (ProviderTable::Iterator i = _providers.start(); i != 0; i++) |
//Provider provider = |
{ |
OpProviderHolder ph = |
ProviderMessageHandler* provider = i.value(); |
providerManager.getProvider(triad.first, triad.second, triad.third); |
PEGASUS_ASSERT(provider != 0); |
*/ |
|
|
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Calling provider.: " + |
|
ph.GetProvider().getName()); |
|
|
|
OperationContext context; |
|
|
|
//l10n |
|
// ATTN-CEC 06/04/03 NOTE: I can't find where the consume msg is sent. This |
|
// does not appear to be hooked-up. When it is added, need to |
|
// make sure that Content-Language is set in the consume msg. |
|
// NOTE: A-L is not needed to be set in the consume msg. |
|
// add the langs to the context |
|
context.insert(ContentLanguageListContainer(request->contentLanguages)); |
|
|
|
CIMInstance indication_copy = request->indicationInstance; |
|
|
|
SimpleIndicationResponseHandler handler; |
|
| |
ph.GetProvider().consumeIndication(context, |
if (provider->status.isInitialized()) |
"", |
|
indication_copy); |
|
} |
|
catch(CIMException & e) |
|
{ | { |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
_unloadProvider(provider); |
"Exception: " + e.getMessage()); |
} |
response->cimException = CIMException(e); |
|
} | } |
catch(Exception & e) |
|
{ |
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Exception: " + e.getMessage()); |
|
//l10n |
|
//response->cimException = CIMException(CIM_ERR_FAILED, "Internal Error"); |
|
response->cimException = CIMException(CIM_ERR_FAILED, MessageLoaderParms( |
|
"ProviderManager.DefaultProviderManager.INTERNAL_ERROR", |
|
"Internal Error")); |
|
} | } |
catch(...) | catch(...) |
{ | { |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, | PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
"Exception: Unknown"); |
"Unexpected Exception in _shutdownAllProviders()."); |
//l10n |
|
//response->cimException = CIMException(CIM_ERR_FAILED, "Unknown Error"); |
|
response->cimException = CIMException(CIM_ERR_FAILED, MessageLoaderParms( |
|
"ProviderManager.DefaultProviderManager.UNKNOWN_ERROR", |
|
"Unknown Error")); |
|
} | } |
| |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
|
|
return(response); |
|
} | } |
| |
// |
Sint16 DefaultProviderManager::_disableProvider(const String& providerName) |
// This function disables a provider module if disableProviderOnly is not true, |
|
// otherwise, disables a provider. Disable provider module means that |
|
// block all the providers which contain in the module and unload the |
|
// providers. |
|
// Disable provider means unload the provider and the provider is not blocked. |
|
// |
|
// ATTN-YZ-P2-20030519: Provider needs to be blocked when disable a provider. |
|
// |
|
Message * DefaultProviderManager::handleDisableModuleRequest(const Message * message) throw() |
|
{ |
|
// HACK |
|
ProviderRegistrationManager * _providerRegistrationManager = ProviderManager::getProviderRegistrationManager(); |
|
|
|
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleDisableModuleRequest"); |
|
|
|
CIMDisableModuleRequestMessage * request = |
|
dynamic_cast<CIMDisableModuleRequestMessage *>(const_cast<Message *>(message)); |
|
|
|
PEGASUS_ASSERT(request != 0); |
|
|
|
// get provider module name |
|
String moduleName; |
|
CIMInstance mInstance = request->providerModule; |
|
Uint32 pos = mInstance.findProperty(CIMName ("Name")); |
|
|
|
if(pos != PEG_NOT_FOUND) |
|
{ | { |
mInstance.getProperty(pos).getValue().get(moduleName); |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, |
} |
"DefaultProviderManager::_disableProvider"); |
|
|
Boolean disableProviderOnly = request->disableProviderOnly; |
|
|
|
// |
|
// get operational status |
|
// |
|
Array<Uint16> operationalStatus; |
|
| |
if(!disableProviderOnly) |
ProviderMessageHandler* pr = _lookupProvider(providerName); |
{ |
if (!pr->status.isInitialized()) |
Uint32 pos2 = mInstance.findProperty(CIMName ("OperationalStatus")); |
|
if(pos2 != PEG_NOT_FOUND) |
|
{ | { |
// |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
// ATTN-CAKG-P2-20020821: Check for null status? |
"Provider " + providerName + " is not loaded"); |
// |
PEG_METHOD_EXIT(); |
mInstance.getProperty(pos2).getValue().get(operationalStatus); |
return 1; |
} | } |
| |
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Disable Provider " + pr->getName()); |
// | // |
// update module status from OK to Stopping |
// Check to see if there are pending requests. If there are pending |
|
// requests and the disable timeout has not expired, loop and wait one |
|
// second until either there is no pending requests or until timeout |
|
// expires. |
// | // |
for(Uint32 i=0, n = operationalStatus.size(); i < n; i++) |
Uint32 waitTime = PROVIDER_DISABLE_TIMEOUT; |
|
while ((pr->status._currentOperations.get() > 0) && (waitTime > 0)) |
{ | { |
if(operationalStatus[i] == _MODULE_OK) |
Threads::sleep(1000); |
{ |
waitTime = waitTime - 1; |
operationalStatus.remove(i); |
|
} |
|
} | } |
operationalStatus.append(_MODULE_STOPPING); |
|
| |
if(_providerRegistrationManager->setProviderModuleStatus |
// There are still pending requests, do not disable |
(moduleName, operationalStatus) == false) |
if (pr->status._currentOperations.get() > 0) |
{ | { |
//l10n |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, "set module status failed."); |
"Disable failed since there are pending requests."); |
throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, MessageLoaderParms( |
PEG_METHOD_EXIT(); |
"ProviderManager.DefaultProviderManager.SET_MODULE_STATUS_FAILED", |
return 0; |
"set module status failed.")); |
|
} |
|
} | } |
| |
// Unload providers |
try |
Array<CIMInstance> _pInstances = request->providers; |
|
|
|
for(Uint32 i = 0, n = _pInstances.size(); i < n; i++) |
|
{ | { |
/* temp disabled by Chip |
AutoMutex lock(_providerTableMutex); |
// get the provider file name and logical name |
|
Triad<String, String, String> triad = |
|
getProviderRegistrar()->_getProviderRegPair(_pInstances[i], mInstance); |
|
| |
providerManager.unloadProvider(triad.first, triad.second); |
if (pr->status.isInitialized()) |
*/ |
|
} |
|
|
|
if(!disableProviderOnly) |
|
{ |
|
// update module status from Stopping to Stopped |
|
for(Uint32 i=0, n = operationalStatus.size(); i < n; i++) |
|
{ |
|
if(operationalStatus[i] == _MODULE_STOPPING) |
|
{ | { |
operationalStatus.remove(i); |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Unloading Provider " + pr->getName()); |
|
_unloadProvider(pr); |
} | } |
} | } |
operationalStatus.append(_MODULE_STOPPED); |
catch (...) |
|
|
if(_providerRegistrationManager->setProviderModuleStatus |
|
(moduleName, operationalStatus) == false) |
|
{ | { |
//l10n |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, |
"Unload provider failed " + pr->getName()); |
//"set module status failed."); |
PEG_METHOD_EXIT(); |
throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, MessageLoaderParms( |
return -1; |
"ProviderManager.DefaultProviderManager.SET_MODULE_STATUS_FAILED", |
|
"set module status failed.")); |
|
} |
|
} | } |
| |
CIMDisableModuleResponseMessage * response = |
|
new CIMDisableModuleResponseMessage( |
|
request->messageId, |
|
CIMException(), |
|
request->queueIds.copyAndPop(), |
|
operationalStatus); |
|
|
|
PEGASUS_ASSERT(response != 0); |
|
|
|
// preserve message key |
|
response->setKey(request->getKey()); |
|
|
|
// |
|
// Set HTTP method in response from request |
|
// |
|
response->setHttpMethod (request->getHttpMethod ()); |
|
|
|
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
|
return 1; |
return(response); |
|
} | } |
| |
Message * DefaultProviderManager::handleEnableModuleRequest(const Message * message) throw() |
void DefaultProviderManager::_unloadProvider(ProviderMessageHandler* provider) |
{ | { |
// HACK |
|
ProviderRegistrationManager * _providerRegistrationManager = ProviderManager::getProviderRegistrationManager(); |
|
|
|
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleEnableModuleRequest"); |
|
|
|
CIMEnableModuleRequestMessage * request = |
|
dynamic_cast<CIMEnableModuleRequestMessage *>(const_cast<Message *>(message)); |
|
|
|
PEGASUS_ASSERT(request != 0); |
|
|
|
// | // |
// get module status |
// NOTE: It is the caller's responsibility to make sure that |
|
// the ProviderTable mutex is locked before calling this method. |
// | // |
CIMInstance mInstance = request->providerModule; |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, |
Array<Uint16> operationalStatus; |
"DefaultProviderManager::_unloadProvider"); |
Uint32 pos = mInstance.findProperty(CIMName ("OperationalStatus")); |
|
| |
if(pos != PEG_NOT_FOUND) |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
{ |
"Unloading Provider " + provider->getName()); |
// |
|
// ATTN-CAKG-P2-20020821: Check for null status? |
|
// |
|
mInstance.getProperty(pos).getValue().get(operationalStatus); |
|
} |
|
| |
// update module status from Stopped to OK |
if (provider->status._currentOperations.get() > 0) |
for(Uint32 i=0, n = operationalStatus.size(); i < n; i++) |
|
{ |
|
if(operationalStatus[i] == _MODULE_STOPPED) |
|
{ | { |
operationalStatus.remove(i); |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
} |
"Provider cannot be unloaded due to pending operations: " + |
|
provider->getName()); |
} | } |
|
else |
|
{ |
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Terminating Provider " + provider->getName()); |
| |
operationalStatus.append(_MODULE_OK); |
// lock the provider mutex |
|
AutoMutex pr_lock(provider->status._statusMutex); |
// |
|
// get module name |
|
// |
|
String moduleName; |
|
|
|
Uint32 pos2 = mInstance.findProperty(CIMName ("Name")); |
|
| |
if(pos2 != PEG_NOT_FOUND) |
try |
{ | { |
mInstance.getProperty(pos2).getValue().get(moduleName); |
provider->terminate(); |
} | } |
|
catch (...) |
if(_providerRegistrationManager->setProviderModuleStatus |
|
(moduleName, operationalStatus) == false) |
|
{ | { |
//l10n |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL3, |
//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, "set module status failed."); |
"Error occured terminating provider " + provider->getName()); |
throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, MessageLoaderParms( |
|
"ProviderManager.DefaultProviderManager.SET_MODULE_STATUS_FAILED", |
|
"set module status failed.")); |
|
} |
|
|
|
CIMEnableModuleResponseMessage * response = |
|
new CIMEnableModuleResponseMessage( |
|
request->messageId, |
|
CIMException(), |
|
request->queueIds.copyAndPop(), |
|
operationalStatus); |
|
|
|
PEGASUS_ASSERT(response != 0); |
|
|
|
// preserve message key |
|
response->setKey(request->getKey()); |
|
|
|
// Set HTTP method in response from request |
|
response->setHttpMethod (request->getHttpMethod ()); |
|
|
|
PEG_METHOD_EXIT(); |
|
|
|
return(response); |
|
} | } |
|
provider->status.setInitialized(false); |
| |
Message * DefaultProviderManager::handleStopAllProvidersRequest(const Message * message) throw() |
PEGASUS_ASSERT(provider->status._module != 0); |
{ |
|
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleStopAllProvidersRequest"); |
|
|
|
CIMStopAllProvidersRequestMessage * request = |
|
dynamic_cast<CIMStopAllProvidersRequestMessage *>(const_cast<Message *>(message)); |
|
|
|
PEGASUS_ASSERT(request != 0); |
|
|
|
CIMStopAllProvidersResponseMessage * response = |
|
new CIMStopAllProvidersResponseMessage( |
|
request->messageId, |
|
CIMException(), |
|
request->queueIds.copyAndPop()); |
|
|
|
PEGASUS_ASSERT(response != 0); |
|
|
|
// preserve message key |
|
response->setKey(request->getKey()); |
|
|
|
// Set HTTP method in response from request |
|
response->setHttpMethod (request->getHttpMethod ()); |
|
|
|
// tell the provider manager to shutdown all the providers |
|
providerManager.shutdownAllProviders(); |
|
|
|
PEG_METHOD_EXIT(); |
|
|
|
return(response); |
|
} |
|
| |
void DefaultProviderManager::_insertEntry ( |
// unload provider module |
const Provider & provider, |
provider->status._module->unloadModule(); |
const EnableIndicationsResponseHandler *handler) |
|
{ |
|
PEG_METHOD_ENTER (TRC_INDICATION_SERVICE, |
|
"DefaultProviderManager::_insertEntry"); |
|
| |
String tableKey = _generateKey |
// NOTE: The "delete provider->status._cimom_handle" operation was |
(provider); |
// moved to be called after the unloadModule() call above |
|
// as part of a fix for bugzilla 3669. For some providers |
|
// run out-of-process on Windows platforms (i.e. running |
|
// the cimserver with the forceProviderProcesses config option |
|
// set to "true"), deleting the provider's CIMOMHandle before |
|
// unloading the provider library caused the unload mechanism |
|
// to deadlock, making that provider unavailable and preventing |
|
// the cimserver from shutting down. It should NOT be moved back |
|
// above the unloadModule() call. See bugzilla 3669 for details. |
|
// delete the cimom handle |
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Destroying Provider's CIMOM Handle " + provider->getName()); |
|
delete provider->status._cimom_handle; |
| |
_responseTable.insert (tableKey, const_cast<EnableIndicationsResponseHandler *>(handler)); |
Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
|
"ProviderManager::_provider_crtl - Unload provider $0", |
|
provider->getName()); |
| |
PEG_METHOD_EXIT(); |
// set provider status to uninitialized |
|
provider->status.reset(); |
} | } |
| |
EnableIndicationsResponseHandler * DefaultProviderManager::_removeEntry( |
|
const String & key) |
|
{ |
|
PEG_METHOD_ENTER (TRC_INDICATION_SERVICE, |
|
"DefaultProviderManager::_removeEntry"); |
|
EnableIndicationsResponseHandler *ret = 0; |
|
|
|
_responseTable.lookup(key, ret); |
|
|
|
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
|
|
return(ret); |
|
} | } |
| |
String DefaultProviderManager::_generateKey ( |
ProviderManager* DefaultProviderManager::createDefaultProviderManagerCallback() |
const Provider & provider) |
|
{ | { |
String tableKey; |
return new DefaultProviderManager(); |
|
|
PEG_METHOD_ENTER (TRC_INDICATION_SERVICE, |
|
"DefaultProviderManager::_generateKey"); |
|
|
|
// |
|
// Append provider key values to key |
|
// |
|
String providerName = provider.getName(); |
|
String providerFileName = provider.getModule()->getFileName(); |
|
tableKey.append (providerName); |
|
tableKey.append (providerFileName); |
|
|
|
PEG_METHOD_EXIT(); |
|
|
|
return(tableKey); |
|
} | } |
| |
PEGASUS_NAMESPACE_END | PEGASUS_NAMESPACE_END |