version 1.11.4.3, 2004/03/10 14:19:29
|
version 1.31, 2004/06/04 02:23:59
|
|
|
// Mike Day, IBM (mdday@us.ibm.com) | // Mike Day, IBM (mdday@us.ibm.com) |
// Karl Schopmeyer(k.schopmeyer@opengroup.org) - Fix associators. | // Karl Schopmeyer(k.schopmeyer@opengroup.org) - Fix associators. |
// Yi Zhou, Hewlett-Packard Company (yi_zhou@hp.com) | // Yi Zhou, Hewlett-Packard Company (yi_zhou@hp.com) |
|
// Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com) |
// | // |
//%///////////////////////////////////////////////////////////////////////////// | //%///////////////////////////////////////////////////////////////////////////// |
| |
|
|
#include <Pegasus/Common/Logger.h> | #include <Pegasus/Common/Logger.h> |
#include <Pegasus/Common/MessageLoader.h> //l10n | #include <Pegasus/Common/MessageLoader.h> //l10n |
| |
//#include <Pegasus/Common/QueryExpression.h> |
#include <Pegasus/Common/QueryExpression.h> |
//#include <Pegasus/ProviderManager2/QueryExpressionFactory.h> |
#include <Pegasus/ProviderManager2/QueryExpressionFactory.h> |
|
|
#include <Pegasus/Config/ConfigManager.h> |
|
| |
#include <Pegasus/ProviderManager2/Default/Provider.h> | #include <Pegasus/ProviderManager2/Default/Provider.h> |
#include <Pegasus/ProviderManager2/OperationResponseHandler.h> | #include <Pegasus/ProviderManager2/OperationResponseHandler.h> |
| |
#include <Pegasus/Server/ProviderRegistrationManager/ProviderRegistrationManager.h> |
|
#include <Pegasus/ProviderManager2/ProviderManagerService.h> | #include <Pegasus/ProviderManager2/ProviderManagerService.h> |
|
#include <Pegasus/ProviderManager2/ProviderType.h> |
| |
PEGASUS_NAMESPACE_BEGIN | PEGASUS_NAMESPACE_BEGIN |
| |
|
|
static const Uint16 _MODULE_STOPPING = 9; | static const Uint16 _MODULE_STOPPING = 9; |
static const Uint16 _MODULE_STOPPED = 10; | static const Uint16 _MODULE_STOPPED = 10; |
| |
// provider manager |
|
static LocalProviderManager providerManager; |
|
| |
|
// |
|
// Default Provider Manager |
|
// |
DefaultProviderManager::DefaultProviderManager(void) | DefaultProviderManager::DefaultProviderManager(void) |
{ | { |
} | } |
|
|
response = handleDeleteInstanceRequest(request); | response = handleDeleteInstanceRequest(request); |
| |
break; | break; |
// case CIM_EXEC_QUERY_REQUEST_MESSAGE: |
case CIM_EXEC_QUERY_REQUEST_MESSAGE: |
// response = handleExecQueryRequest(request); |
response = handleExecQueryRequest(request); |
| |
// break; |
break; |
case CIM_ASSOCIATORS_REQUEST_MESSAGE: | case CIM_ASSOCIATORS_REQUEST_MESSAGE: |
response = handleAssociatorsRequest(request); | response = handleAssociatorsRequest(request); |
| |
|
|
response = handleStopAllProvidersRequest(request); | response = handleStopAllProvidersRequest(request); |
| |
break; | break; |
|
case CIM_INITIALIZE_PROVIDER_REQUEST_MESSAGE: |
|
response = handleInitializeProviderRequest(request); |
|
|
|
break; |
default: | default: |
response = handleUnsupportedRequest(request); | response = handleUnsupportedRequest(request); |
| |
|
|
return(0); | return(0); |
} | } |
| |
|
Message * DefaultProviderManager::handleInitializeProviderRequest( |
|
const Message * message) |
|
{ |
|
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, |
|
"DefaultProviderManager::handleInitializeProviderRequest"); |
|
|
|
CIMInitializeProviderRequestMessage * request = |
|
dynamic_cast<CIMInitializeProviderRequestMessage *> |
|
(const_cast<Message *>(message)); |
|
|
|
PEGASUS_ASSERT(request != 0); |
|
|
|
CIMInitializeProviderResponseMessage * response = |
|
new CIMInitializeProviderResponseMessage( |
|
request->messageId, |
|
CIMException(), |
|
request->queueIds.copyAndPop()); |
|
|
|
// preserve message key |
|
response->setKey(request->getKey()); |
|
|
|
// Set HTTP method in response from request |
|
response->setHttpMethod(request->getHttpMethod()); |
|
|
|
OperationResponseHandler handler(request, response); |
|
|
|
try |
|
{ |
|
// resolve provider name |
|
ProviderName name = _resolveProviderName( |
|
request->operationContext.get(ProviderIdContainer::NAME)); |
|
|
|
// get cached or load new provider module |
|
OpProviderHolder ph = |
|
providerManager.getProvider(name.getPhysicalName(), |
|
name.getLogicalName(), String::EMPTY); |
|
|
|
} |
|
catch(CIMException & e) |
|
{ |
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL3, |
|
"CIMException: " + e.getMessage()); |
|
|
|
handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); |
|
} |
|
catch(Exception & e) |
|
{ |
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL3, |
|
"Exception: " + e.getMessage()); |
|
|
|
handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); |
|
} |
|
catch(...) |
|
{ |
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL3, |
|
"Exception: Unknown"); |
|
|
|
handler.setStatus(CIM_ERR_FAILED, "Unknown error."); |
|
} |
|
|
|
PEG_METHOD_EXIT(); |
|
|
|
return(response); |
|
} |
|
|
Message * DefaultProviderManager::handleGetInstanceRequest(const Message * message) | Message * DefaultProviderManager::handleGetInstanceRequest(const Message * message) |
{ | { |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleGetInstanceRequest"); | PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleGetInstanceRequest"); |
|
|
request->instanceName.getClassName(), | request->instanceName.getClassName(), |
request->instanceName.getKeyBindings()); | request->instanceName.getKeyBindings()); |
| |
ProviderName name( |
|
objectPath, |
|
ProviderType::INSTANCE); |
|
|
|
// resolve provider name | // resolve provider name |
name = _resolveProviderName(name); |
ProviderName name = _resolveProviderName( |
|
request->operationContext.get(ProviderIdContainer::NAME)); |
| |
// get cached or load new provider module | // get cached or load new provider module |
OpProviderHolder ph = | OpProviderHolder ph = |
|
|
request->nameSpace, | request->nameSpace, |
request->className); | request->className); |
| |
ProviderName name( |
|
objectPath, |
|
ProviderType::INSTANCE); |
|
|
|
// resolve provider name | // resolve provider name |
name = _resolveProviderName(name); |
ProviderName name = _resolveProviderName( |
|
request->operationContext.get(ProviderIdContainer::NAME)); |
| |
// get cached or load new provider module | // get cached or load new provider module |
OpProviderHolder ph = providerManager.getProvider(name.getPhysicalName(), | OpProviderHolder ph = providerManager.getProvider(name.getPhysicalName(), |
|
|
request->nameSpace, | request->nameSpace, |
request->className); | request->className); |
| |
// build an internal provider name from the request arguments |
|
ProviderName name( |
|
objectPath, |
|
ProviderType::INSTANCE); |
|
|
|
// resolve provider name | // resolve provider name |
name = _resolveProviderName(name); |
ProviderName name = _resolveProviderName( |
|
request->operationContext.get(ProviderIdContainer::NAME)); |
| |
// get cached or load new provider module | // get cached or load new provider module |
OpProviderHolder ph = | OpProviderHolder ph = |
|
|
request->newInstance.getPath().getClassName(), | request->newInstance.getPath().getClassName(), |
request->newInstance.getPath().getKeyBindings()); | request->newInstance.getPath().getKeyBindings()); |
| |
ProviderName name( |
|
objectPath, |
|
ProviderType::INSTANCE); |
|
|
|
// resolve provider name | // resolve provider name |
name = _resolveProviderName(name); |
ProviderName name = _resolveProviderName( |
|
request->operationContext.get(ProviderIdContainer::NAME)); |
| |
// get cached or load new provider module | // get cached or load new provider module |
OpProviderHolder ph = | OpProviderHolder ph = |
|
|
request->modifiedInstance.getPath ().getClassName(), | request->modifiedInstance.getPath ().getClassName(), |
request->modifiedInstance.getPath ().getKeyBindings()); | request->modifiedInstance.getPath ().getKeyBindings()); |
| |
ProviderName name( |
|
objectPath, |
|
ProviderType::INSTANCE); |
|
|
|
// resolve provider name | // resolve provider name |
name = _resolveProviderName(name); |
ProviderName name = _resolveProviderName( |
|
request->operationContext.get(ProviderIdContainer::NAME)); |
| |
// get cached or load new provider module | // get cached or load new provider module |
OpProviderHolder ph = | OpProviderHolder ph = |
|
|
request->instanceName.getClassName(), | request->instanceName.getClassName(), |
request->instanceName.getKeyBindings()); | request->instanceName.getKeyBindings()); |
| |
ProviderName name( |
|
objectPath, |
|
ProviderType::INSTANCE); |
|
|
|
// resolve provider name | // resolve provider name |
name = _resolveProviderName(name); |
ProviderName name = _resolveProviderName( |
|
request->operationContext.get(ProviderIdContainer::NAME)); |
| |
// get cached or load new provider module | // get cached or load new provider module |
OpProviderHolder ph = | OpProviderHolder ph = |
|
|
| |
return(response); | return(response); |
} | } |
/* |
|
Message * DefaultProviderManager::handleExecQueryRequest(const Message * message) | Message * DefaultProviderManager::handleExecQueryRequest(const Message * message) |
{ | { |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleExecQueryRequest"); | PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleExecQueryRequest"); |
|
|
request->nameSpace, | request->nameSpace, |
request->className); | request->className); |
| |
ProviderName name( |
|
objectPath, |
|
ProviderType::QUERY); |
|
|
|
// resolve provider name | // resolve provider name |
name = _resolveProviderName(name); |
ProviderName name = _resolveProviderName( |
|
request->operationContext.get(ProviderIdContainer::NAME)); |
| |
// get cached or load new provider module | // get cached or load new provider module |
OpProviderHolder ph = | OpProviderHolder ph = |
|
|
} | } |
catch(Exception & e) | catch(Exception & e) |
{ | { |
cout<<"--- exception not a CIMInstanceQueryProvider"<<endl; |
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, | PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
"Exception: " + e.getMessage()); | "Exception: " + e.getMessage()); |
| |
|
|
| |
return(response); | return(response); |
} | } |
*/ |
|
Message * DefaultProviderManager::handleAssociatorsRequest(const Message * message) | Message * DefaultProviderManager::handleAssociatorsRequest(const Message * message) |
{ | { |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleAssociatorsRequest"); | PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleAssociatorsRequest"); |
|
|
request->nameSpace, | request->nameSpace, |
request->assocClass.getString()); | request->assocClass.getString()); |
| |
ProviderName name( |
|
assocPath, |
|
ProviderType::ASSOCIATION); |
|
|
|
// resolve provider name | // resolve provider name |
name = _resolveProviderName(name); |
ProviderName name = _resolveProviderName( |
|
request->operationContext.get(ProviderIdContainer::NAME)); |
| |
// get cached or load new provider module | // get cached or load new provider module |
OpProviderHolder ph = | OpProviderHolder ph = |
|
|
request->nameSpace, | request->nameSpace, |
request->assocClass.getString()); | request->assocClass.getString()); |
| |
ProviderName name( |
|
assocPath, |
|
ProviderType::ASSOCIATION); |
|
|
|
// resolve provider name | // resolve provider name |
name = _resolveProviderName(name); |
ProviderName name = _resolveProviderName( |
|
request->operationContext.get(ProviderIdContainer::NAME)); |
| |
// get cached or load new provider module | // get cached or load new provider module |
OpProviderHolder ph = | OpProviderHolder ph = |
|
|
request->nameSpace, | request->nameSpace, |
request->resultClass.getString()); | request->resultClass.getString()); |
| |
ProviderName name( |
|
resultPath, |
|
ProviderType::ASSOCIATION); |
|
|
|
// resolve provider name | // resolve provider name |
name = _resolveProviderName(name); |
ProviderName name = _resolveProviderName( |
|
request->operationContext.get(ProviderIdContainer::NAME)); |
| |
// get cached or load new provider module | // get cached or load new provider module |
OpProviderHolder ph = | OpProviderHolder ph = |
|
|
request->nameSpace, | request->nameSpace, |
request->resultClass.getString()); | request->resultClass.getString()); |
| |
ProviderName name( |
|
resultPath, |
|
ProviderType::ASSOCIATION); |
|
|
|
// resolve provider name | // resolve provider name |
name = _resolveProviderName(name); |
ProviderName name = _resolveProviderName( |
|
request->operationContext.get(ProviderIdContainer::NAME)); |
| |
// get cached or load new provider module | // get cached or load new provider module |
OpProviderHolder ph = | OpProviderHolder ph = |
|
|
request->instanceName.getClassName(), | request->instanceName.getClassName(), |
request->instanceName.getKeyBindings()); | request->instanceName.getKeyBindings()); |
| |
ProviderName name( |
|
objectPath, |
|
0); |
|
|
|
// resolve provider name | // resolve provider name |
name = _resolveProviderName(name); |
ProviderName name = _resolveProviderName( |
|
request->operationContext.get(ProviderIdContainer::NAME)); |
| |
// get cached or load new provider module | // get cached or load new provider module |
OpProviderHolder ph = | OpProviderHolder ph = |
|
|
request->instanceName.getClassName(), | request->instanceName.getClassName(), |
request->instanceName.getKeyBindings()); | request->instanceName.getKeyBindings()); |
| |
ProviderName name( |
|
objectPath, |
|
0); |
|
|
|
// resolve provider name | // resolve provider name |
name = _resolveProviderName(name); |
ProviderName name = _resolveProviderName( |
|
request->operationContext.get(ProviderIdContainer::NAME)); |
| |
// get cached or load new provider module | // get cached or load new provider module |
OpProviderHolder ph = | OpProviderHolder ph = |
|
|
request->instanceName.getClassName(), | request->instanceName.getClassName(), |
request->instanceName.getKeyBindings()); | request->instanceName.getKeyBindings()); |
| |
ProviderName name( |
|
objectPath, |
|
ProviderType::METHOD, |
|
request->methodName); |
|
|
|
// resolve provider name | // resolve provider name |
name = _resolveProviderName(name); |
ProviderName name = _resolveProviderName( |
|
request->operationContext.get(ProviderIdContainer::NAME)); |
| |
// get cached or load new provider module | // get cached or load new provider module |
OpProviderHolder ph = | OpProviderHolder ph = |
|
|
CIMException(), | CIMException(), |
request->queueIds.copyAndPop()); | request->queueIds.copyAndPop()); |
| |
CIMEnableIndicationsResponseMessage * responseforhandler = |
|
new CIMEnableIndicationsResponseMessage( |
|
request->messageId, |
|
CIMException(), |
|
request->queueIds.copyAndPop()); |
|
|
|
PEGASUS_ASSERT(response != 0); | PEGASUS_ASSERT(response != 0); |
| |
// preserve message key | // preserve message key |
|
|
| |
response->dest = request->queueIds.top(); | response->dest = request->queueIds.top(); |
| |
// ATTN: need pointer to Provider Manager Server! |
|
EnableIndicationsResponseHandler *handler = | EnableIndicationsResponseHandler *handler = |
new EnableIndicationsResponseHandler(request, response, |
new EnableIndicationsResponseHandler( |
request->provider, ProviderManagerService::providerManagerService); |
request, response, request->provider, _indicationCallback); |
| |
try | try |
{ | { |
|
|
ph.GetProvider().getName()); | ph.GetProvider().getName()); |
| |
pm_service_op_lock op_lock(&ph.GetProvider()); | pm_service_op_lock op_lock(&ph.GetProvider()); |
|
ph.GetProvider().protect(); |
| |
ph.GetProvider().enableIndications(*handler); | ph.GetProvider().enableIndications(*handler); |
| |
|
|
| |
try | try |
{ | { |
ProviderName name( |
|
String::EMPTY, |
|
String::EMPTY, |
|
String::EMPTY, |
|
0); |
|
|
|
/* |
|
ProviderName name( |
|
String::EMPTY, |
|
String::EMPTY, |
|
objectPath.toString()); |
|
|
|
// resolve provider name | // resolve provider name |
name = _resolveProviderName(name); |
ProviderName name = _resolveProviderName( |
*/ |
request->operationContext.get(ProviderIdContainer::NAME)); |
| |
// get cached or load new provider module | // get cached or load new provider module |
OpProviderHolder ph = | OpProviderHolder ph = |
|
|
| |
try | try |
{ | { |
ProviderName name( |
|
String::EMPTY, |
|
String::EMPTY, |
|
String::EMPTY, |
|
0); |
|
|
|
// resolve provider name | // resolve provider name |
name = _resolveProviderName(request->destinationPath); |
ProviderName name = _resolveProviderName( |
|
request->operationContext.get(ProviderIdContainer::NAME)); |
| |
// get cached or load new provider module | // get cached or load new provider module |
OpProviderHolder ph = | OpProviderHolder ph = |
|
|
PEGASUS_ASSERT(request != 0); | PEGASUS_ASSERT(request != 0); |
| |
Array<Uint16> operationalStatus; | Array<Uint16> operationalStatus; |
Boolean disableProviderOnly = request->disableProviderOnly; |
|
CIMException cimException; | CIMException cimException; |
| |
ProviderRegistrationManager * _providerRegistrationManager = GetProviderRegistrationManager(); |
|
|
|
try | try |
{ | { |
// get provider module name | // get provider module name |
String moduleName; | String moduleName; |
CIMInstance mInstance = request->providerModule; | CIMInstance mInstance = request->providerModule; |
Uint32 pos = mInstance.findProperty(CIMName ("Name")); | Uint32 pos = mInstance.findProperty(CIMName ("Name")); |
|
PEGASUS_ASSERT(pos != PEG_NOT_FOUND); |
if(pos != PEG_NOT_FOUND) |
|
{ |
|
mInstance.getProperty(pos).getValue().get(moduleName); | mInstance.getProperty(pos).getValue().get(moduleName); |
} |
|
| |
Boolean disableProviderOnly = request->disableProviderOnly; | Boolean disableProviderOnly = request->disableProviderOnly; |
| |
// | // |
// get operational status |
|
// |
|
if (!disableProviderOnly) |
|
{ |
|
Uint32 pos2 = mInstance.findProperty(CIMName ("OperationalStatus")); |
|
if (pos2 != PEG_NOT_FOUND) |
|
{ |
|
// |
|
// ATTN-CAKG-P2-20020821: Check for null status? |
|
// |
|
mInstance.getProperty(pos2).getValue().get(operationalStatus); |
|
} |
|
|
|
// |
|
// update module status from OK to Stopping |
|
// |
|
for (Uint32 i=0, n = operationalStatus.size(); i < n; i++) |
|
{ |
|
if (operationalStatus[i] == _MODULE_OK) |
|
{ |
|
operationalStatus.remove(i); |
|
} |
|
} |
|
|
|
operationalStatus.append(_MODULE_STOPPING); |
|
|
|
if(_providerRegistrationManager->setProviderModuleStatus |
|
(moduleName, operationalStatus) == false) |
|
{ |
|
//l10n |
|
//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, "set module status failed."); |
|
throw PEGASUS_CIM_EXCEPTION_L( |
|
CIM_ERR_FAILED, |
|
MessageLoaderParms( |
|
"ProviderManager.ProviderManagerService." |
|
"SET_MODULE_STATUS_FAILED", |
|
"set module status failed.")); |
|
} |
|
} |
|
|
|
// Unload providers | // Unload providers |
|
// |
Array<CIMInstance> _pInstances = request->providers; | Array<CIMInstance> _pInstances = request->providers; |
Array<Boolean> _indicationProviders = request->indicationProviders; | Array<Boolean> _indicationProviders = request->indicationProviders; |
| |
|
|
if (ret_value == 0) | if (ret_value == 0) |
{ | { |
// disable failed since there are pending requests, | // disable failed since there are pending requests, |
// update module status from Stopping to OK if |
// stop trying to disable other providers in this module. |
// disableProviderOnly is not true |
|
if (!disableProviderOnly) |
|
{ |
|
for(Uint32 j=0, m = operationalStatus.size(); j < m; j++) |
|
{ |
|
if (operationalStatus[j] == _MODULE_STOPPING) |
|
{ |
|
operationalStatus.remove(j); |
|
} |
|
} |
|
|
|
operationalStatus.append(_MODULE_OK); | operationalStatus.append(_MODULE_OK); |
|
break; |
if(_providerRegistrationManager->setProviderModuleStatus |
|
(moduleName, operationalStatus) == false) |
|
{ |
|
throw PEGASUS_CIM_EXCEPTION_L( |
|
CIM_ERR_FAILED, |
|
MessageLoaderParms( |
|
"ProviderManager.ProviderManagerService." |
|
"SET_MODULE_STATUS_FAILED", |
|
"set module status failed.")); |
|
} |
|
} |
|
} | } |
else if (ret_value == 1) |
else if (ret_value == 1) // Success |
{ | { |
// if It is an indication provider | // if It is an indication provider |
// remove the entry from the table since the | // remove the entry from the table since the |
// provider has been disabled | // provider has been disabled |
if (_indicationProviders[i]) | if (_indicationProviders[i]) |
{ | { |
_removeEntry(_generateKey(pName,physicalName)); |
delete _removeEntry(_generateKey(pName,physicalName)); |
} | } |
} | } |
else | else |
{ | { |
// disable failed for other reason, throw exception | // disable failed for other reason, throw exception |
// update module status from Stopping to OK if |
|
// disableProviderOnly is not true |
|
if (!disableProviderOnly) |
|
{ |
|
for(Uint32 j=0, m = operationalStatus.size(); j < m; j++) |
|
{ |
|
if (operationalStatus[j] == _MODULE_STOPPING) |
|
{ |
|
operationalStatus.remove(j); |
|
} |
|
} |
|
|
|
operationalStatus.append(_MODULE_OK); |
|
|
|
if(_providerRegistrationManager->setProviderModuleStatus |
|
(moduleName, operationalStatus) == false) |
|
{ |
|
throw PEGASUS_CIM_EXCEPTION_L( |
|
CIM_ERR_FAILED, |
|
MessageLoaderParms( |
|
"ProviderManager.ProviderManagerService." |
|
"SET_MODULE_STATUS_FAILED", |
|
"set module status failed.")); |
|
} |
|
} |
|
|
|
throw PEGASUS_CIM_EXCEPTION_L( | throw PEGASUS_CIM_EXCEPTION_L( |
CIM_ERR_FAILED, | CIM_ERR_FAILED, |
MessageLoaderParms( | MessageLoaderParms( |
|
|
"Failed to disable the provider.")); | "Failed to disable the provider.")); |
} | } |
} | } |
// disable succeed |
|
// update module status from Stopping to Stopped if |
|
// disableProviderOnly is not true |
|
if (!disableProviderOnly) |
|
{ |
|
// update module status from Stopping to Stopped |
|
for(Uint32 j=0, m = operationalStatus.size(); j < m; j++) |
|
{ |
|
if (operationalStatus[j] == _MODULE_STOPPING) |
|
{ |
|
operationalStatus.remove(j); |
|
operationalStatus.append(_MODULE_STOPPED); |
|
} |
|
} |
|
|
|
if(_providerRegistrationManager->setProviderModuleStatus |
|
(moduleName, operationalStatus) == false) |
|
{ |
|
//l10n |
|
//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, |
|
//"set module status failed."); |
|
throw PEGASUS_CIM_EXCEPTION_L( |
|
CIM_ERR_FAILED, |
|
MessageLoaderParms( |
|
"ProviderManager.ProviderManagerService." |
|
"SET_MODULE_STATUS_FAILED", |
|
"set module status failed.")); |
|
} |
|
} |
|
} | } |
catch(CIMException & e) | catch(CIMException & e) |
{ | { |
|
|
"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(_MODULE_STOPPED); |
|
} |
|
} |
|
else |
|
{ |
|
// If exception occurs, module is not stopped |
|
operationalStatus.append(_MODULE_OK); |
|
} |
|
|
CIMDisableModuleResponseMessage * response = | CIMDisableModuleResponseMessage * response = |
new CIMDisableModuleResponseMessage( | new CIMDisableModuleResponseMessage( |
request->messageId, | request->messageId, |
|
|
| |
Message * DefaultProviderManager::handleEnableModuleRequest(const Message * message) | Message * DefaultProviderManager::handleEnableModuleRequest(const Message * message) |
{ | { |
// HACK |
|
ProviderRegistrationManager * _providerRegistrationManager = GetProviderRegistrationManager(); |
|
|
|
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleEnableModuleRequest"); | PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleEnableModuleRequest"); |
| |
CIMEnableModuleRequestMessage * request = | CIMEnableModuleRequestMessage * request = |
|
|
| |
PEGASUS_ASSERT(request != 0); | PEGASUS_ASSERT(request != 0); |
| |
// |
|
// get module status |
|
// |
|
CIMInstance mInstance = request->providerModule; |
|
Array<Uint16> operationalStatus; | Array<Uint16> operationalStatus; |
Uint32 pos = mInstance.findProperty(CIMName ("OperationalStatus")); |
|
|
|
if(pos != PEG_NOT_FOUND) |
|
{ |
|
// |
|
// ATTN-CAKG-P2-20020821: Check for null status? |
|
// |
|
mInstance.getProperty(pos).getValue().get(operationalStatus); |
|
} |
|
|
|
// update module status from Stopped to OK |
|
for(Uint32 i=0, n = operationalStatus.size(); i < n; i++) |
|
{ |
|
if(operationalStatus[i] == _MODULE_STOPPED) |
|
{ |
|
operationalStatus.remove(i); |
|
} |
|
} |
|
|
|
operationalStatus.append(_MODULE_OK); | operationalStatus.append(_MODULE_OK); |
| |
// |
|
// get module name |
|
// |
|
String moduleName; |
|
|
|
Uint32 pos2 = mInstance.findProperty(CIMName ("Name")); |
|
|
|
if(pos2 != PEG_NOT_FOUND) |
|
{ |
|
mInstance.getProperty(pos2).getValue().get(moduleName); |
|
} |
|
|
|
if(_providerRegistrationManager->setProviderModuleStatus |
|
(moduleName, operationalStatus) == false) |
|
{ |
|
//l10n |
|
//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, "set module status failed."); |
|
throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, MessageLoaderParms( |
|
"ProviderManager.DefaultProviderManager.SET_MODULE_STATUS_FAILED", |
|
"set module status failed.")); |
|
} |
|
|
|
CIMEnableModuleResponseMessage * response = | CIMEnableModuleResponseMessage * response = |
new CIMEnableModuleResponseMessage( | new CIMEnableModuleResponseMessage( |
request->messageId, | request->messageId, |
|
|
request->queueIds.copyAndPop(), | request->queueIds.copyAndPop(), |
operationalStatus); | operationalStatus); |
| |
PEGASUS_ASSERT(response != 0); |
|
|
|
// preserve message key | // preserve message key |
response->setKey(request->getKey()); | response->setKey(request->getKey()); |
| |
|
|
response->setHttpMethod (request->getHttpMethod ()); | response->setHttpMethod (request->getHttpMethod ()); |
| |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
|
|
return(response); | return(response); |
} | } |
| |
|
|
return tableKey; | return tableKey; |
} | } |
| |
ProviderName DefaultProviderManager::_resolveProviderName(const ProviderName & providerName) |
ProviderName DefaultProviderManager::_resolveProviderName( |
|
const ProviderIdContainer & providerId) |
{ | { |
ProviderName temp = findProvider(providerName); |
String providerName; |
String physicalName = _resolvePhysicalName(temp.getPhysicalName()); |
String fileName; |
temp.setPhysicalName(physicalName); |
String interfaceName; |
|
CIMValue genericValue; |
|
|
|
genericValue = providerId.getProvider().getProperty( |
|
providerId.getProvider().findProperty("Name")).getValue(); |
|
genericValue.get(providerName); |
|
|
|
genericValue = providerId.getModule().getProperty( |
|
providerId.getModule().findProperty("Location")).getValue(); |
|
genericValue.get(fileName); |
|
fileName = _resolvePhysicalName(fileName); |
|
|
|
// ATTN: This attribute is probably not required |
|
genericValue = providerId.getModule().getProperty( |
|
providerId.getModule().findProperty("InterfaceType")).getValue(); |
|
genericValue.get(interfaceName); |
| |
return(temp); |
// Check if the provider module is blocked |
} |
Array<Uint16> operationalStatus; |
|
Uint32 pos = providerId.getModule().findProperty( |
|
CIMName("OperationalStatus")); |
|
PEGASUS_ASSERT(pos != PEG_NOT_FOUND); |
|
providerId.getModule().getProperty(pos).getValue().get(operationalStatus); |
| |
ProviderName DefaultProviderManager::_resolveProviderName(String & destinationPath) |
for(Uint32 i = 0; i < operationalStatus.size(); i++) |
|
{ |
|
if(operationalStatus[i] == _MODULE_STOPPED || |
|
operationalStatus[i] == _MODULE_STOPPING) |
{ | { |
ProviderName temp = findProvider(destinationPath); |
throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_ACCESS_DENIED, |
|
MessageLoaderParms( |
|
"ProviderManager.ProviderManagerService.PROVIDER_BLOCKED", |
|
"provider blocked.")); |
|
} |
|
} |
| |
String physicalName = _resolvePhysicalName(temp.getPhysicalName()); |
return ProviderName(providerName, fileName, interfaceName, 0); |
|
} |
| |
temp.setPhysicalName(physicalName); |
Boolean DefaultProviderManager::hasActiveProviders() |
|
{ |
|
return providerManager.hasActiveProviders(); |
|
} |
| |
return(temp); |
void DefaultProviderManager::unloadIdleProviders() |
|
{ |
|
providerManager.unloadIdleProviders(); |
} | } |
| |
PEGASUS_NAMESPACE_END | PEGASUS_NAMESPACE_END |