pegasus/src/Pegasus/ProviderManager2/Default/DefaultProviderManager.cpp - diff

Return to DefaultProviderManager.cpp CVS log

Up to [Pegasus] / pegasus / src / Pegasus / ProviderManager2 / Default

Diff for /pegasus/src/Pegasus/ProviderManager2/Default/DefaultProviderManager.cpp between version 1.1 and 1.61.2.3

version 1.1, 2003/08/18 04:27:16

version 1.61.2.3, 2007/01/23 18:28:43

Line 1

//%/////////////////////////////////////////////////////////////////////////////

//%2006////////////////////////////////////////////////////////////////////////

// The Open Group, Tivoli Systems

// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.

// IBM Corp.; EMC Corporation, The Open Group.

// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.

// EMC Corporation; VERITAS Software Corporation; The Open Group.

// EMC Corporation; Symantec Corporation; The Open Group.

// Permission is hereby granted, free of charge, to any person obtaining a copy

// of this software and associated documentation files (the "Software"), to

Line 28

Line 36

// Mike Day, IBM (mdday@us.ibm.com)

// Karl Schopmeyer(k.schopmeyer@opengroup.org) - Fix associators.

// Yi Zhou, Hewlett-Packard Company (yi_zhou@hp.com)

// Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)

// Seema Gupta (gseema@in.ibm.com) for PEP135

// Willis White (whiwill@us.ibm.com)

// Josephine Eskaline Joyce (jojustin@in.ibm.com) for PEP#101

//%/////////////////////////////////////////////////////////////////////////////

Line 35

Line 47

#include <Pegasus/Common/CIMMessage.h>

#include <Pegasus/Common/OperationContext.h>

#include <Pegasus/Common/Destroyer.h>

#include <Pegasus/Common/Tracer.h>

#include <Pegasus/Common/StatisticalData.h>

#include <Pegasus/Common/Logger.h>

#include <Pegasus/Common/MessageLoader.h> //l10n

#include <Pegasus/Common/Constants.h>

#include <Pegasus/Config/ConfigManager.h>

#include <Pegasus/Query/QueryExpression/QueryExpression.h>

#include <Pegasus/ProviderManager2/QueryExpressionFactory.h>

#include <Pegasus/ProviderManager2/Default/Provider.h>

#include <Pegasus/ProviderManager2/Default/OperationResponseHandler.h>

#include <Pegasus/ProviderManager2/OperationResponseHandler.h>

#include <Pegasus/ProviderManager2/ProviderManagerService.h>

#include <Pegasus/ProviderManager2/ProviderType.h>

#define HandleCatch(handler) \

catch(CIMException & e) \

{ \

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, \

"Exception: " + e.getMessage()); \

handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); \

} \

catch(Exception & e) \

{ \

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, \

"Exception: " + e.getMessage()); \

handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage());\

} \

catch(...) \

{ \

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, \

"Exception: Unknown"); \

handler.setStatus(CIM_ERR_FAILED, "Unknown error."); \

} \

STAT_RESPONSEEND

#include <Pegasus/Server/ProviderRegistrationManager/ProviderRegistrationManager.h>

PEGASUS_NAMESPACE_BEGIN

Line 71

Line 107

};

// Provider module status

// Default Provider Manager

static const Uint16 _MODULE_OK = 2;

static const Uint16 _MODULE_STOPPING = 9;

static const Uint16 _MODULE_STOPPED = 10;

// provider manager

LocalProviderManager providerManager;

DefaultProviderManager::DefaultProviderManager(void)

{

_subscriptionInitComplete = false;

}

DefaultProviderManager::~DefaultProviderManager(void)

Line 123

Line 153

break;

case CIM_EXEC_QUERY_REQUEST_MESSAGE:

response = handleExecuteQueryRequest(request);

response = handleExecQueryRequest(request);

break;

case CIM_ASSOCIATORS_REQUEST_MESSAGE:

Line 166

Line 196

response = handleDeleteSubscriptionRequest(request);

break;

case CIM_ENABLE_INDICATIONS_REQUEST_MESSAGE:

case CIM_EXPORT_INDICATION_REQUEST_MESSAGE:

response = handleEnableIndicationsRequest(request);

response = handleExportIndicationRequest(request);

break;

case CIM_DISABLE_INDICATIONS_REQUEST_MESSAGE:

response = handleDisableIndicationsRequest(request);

break;

case CIM_CONSUME_INDICATION_REQUEST_MESSAGE:

response = handleConsumeIndicationRequest(request);

break;

case CIM_DISABLE_MODULE_REQUEST_MESSAGE:

Line 190

Line 212

response = handleStopAllProvidersRequest(request);

break;

case CIM_INITIALIZE_PROVIDER_REQUEST_MESSAGE:

response = handleInitializeProviderRequest(request);

break;

case CIM_SUBSCRIPTION_INIT_COMPLETE_REQUEST_MESSAGE:

response = handleSubscriptionInitCompleteRequest (request);

break;

default:

response = handleUnsupportedRequest(request);

Line 201

Line 231

return(response);

}

Message * DefaultProviderManager::handleUnsupportedRequest(const Message * message) throw()

Message * DefaultProviderManager::handleUnsupportedRequest(const Message * message)

{

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleUnsupportedRequest");

Line 211

Line 241

return(0);

}

Message * DefaultProviderManager::handleGetInstanceRequest(const Message * message) throw()

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 =

dynamic_cast<CIMInitializeProviderResponseMessage*>(

request->buildResponse());

PEGASUS_ASSERT(response != 0);

OperationResponseHandler handler(

request, response, _responseChunkCallback);

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());

}

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)

{

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleGetInstanceRequest");

Line 221

Line 308

PEGASUS_ASSERT(request != 0);

CIMGetInstanceResponseMessage * response =

new CIMGetInstanceResponseMessage(

dynamic_cast<CIMGetInstanceResponseMessage*>(

request->messageId,

request->buildResponse());

CIMException(),

request->queueIds.copyAndPop(),

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

GetInstanceResponseHandler handler(request, response);

GetInstanceResponseHandler handler(

request, response, _responseChunkCallback);

try

{

Line 253

Line 331

request->instanceName.getClassName(),

request->instanceName.getKeyBindings());

InternalProviderName name(

// resolve provider name

String::EMPTY,

ProviderName name = _resolveProviderName(

String::EMPTY,

request->operationContext.get(ProviderIdContainer::NAME));

objectPath.toString());

name = findProvider(name.toString());

// get cached or load new provider module

OpProviderHolder ph =

OpProviderHolder ph = providerManager.getProvider(

providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);

name.getPhysicalName(), name.getLogicalName());

// convert arguments

OperationContext context;

context.insert(IdentityContainer(request->userName));

context.insert(request->operationContext.get(IdentityContainer::NAME));

context.insert(AcceptLanguageListContainer(request->acceptLanguages));

context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));

context.insert(ContentLanguageListContainer(request->contentLanguages));

context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));

CIMPropertyList propertyList(request->propertyList);

Line 280

Line 355

pm_service_op_lock op_lock(&ph.GetProvider());

STAT_GETSTARTTIME;

STAT_PMS_PROVIDERSTART;

ph.GetProvider().getInstance(

context,

Line 289

Line 364

request->includeClassOrigin,

propertyList,

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.");

}

HandleCatch(handler);

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

return(response);

}

Message * DefaultProviderManager::handleEnumerateInstancesRequest(const Message * message) throw()

Message * DefaultProviderManager::handleEnumerateInstancesRequest(const Message * message)

{

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleEnumerateInstanceRequest");

Line 327

Line 384

PEGASUS_ASSERT(request != 0);

CIMEnumerateInstancesResponseMessage * response =

new CIMEnumerateInstancesResponseMessage(

dynamic_cast<CIMEnumerateInstancesResponseMessage*>(

request->messageId,

request->buildResponse());

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);

EnumerateInstancesResponseHandler handler(

request, response, _responseChunkCallback);

try

{

Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,

PEG_LOGGER_TRACE((Logger::STANDARD_LOG, System::CIMSERVER,

"DefaultProviderManager::handleEnumerateInstancesRequest - Host name: $0 Name space: $1 Class name: $2",

Logger::TRACE,

"DefaultProviderManager::handleEnumerateInstancesRequest - "

"Host name: $0 Name space: $1 Class name: $2",

System::getHostName(),

request->nameSpace.getString(),

request->className.getString());

request->className.getString()));

// make target object path

CIMObjectPath objectPath(

Line 358

Line 408

request->nameSpace,

request->className);

InternalProviderName name(

// resolve provider name

String::EMPTY,

ProviderName name = _resolveProviderName(

String::EMPTY,

request->operationContext.get(ProviderIdContainer::NAME));

objectPath.toString());

name = findProvider(name.toString());

// get cached or load new provider module

OpProviderHolder ph =

OpProviderHolder ph = providerManager.getProvider(

providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);

name.getPhysicalName(), name.getLogicalName());

// convert arguments

OperationContext context;

context.insert(IdentityContainer(request->userName));

context.insert(request->operationContext.get(IdentityContainer::NAME));

context.insert(AcceptLanguageListContainer(request->acceptLanguages));

context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));

context.insert(ContentLanguageListContainer(request->contentLanguages));

context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));

CIMPropertyList propertyList(request->propertyList);

Line 385

Line 432

pm_service_op_lock op_lock(&ph.GetProvider());

STAT_GETSTARTTIME;

STAT_PMS_PROVIDERSTART;

ph.GetProvider().enumerateInstances(

context,

Line 394

Line 441

request->includeClassOrigin,

propertyList,

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.");

}

HandleCatch(handler);

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

return(response);

}

Message * DefaultProviderManager::handleEnumerateInstanceNamesRequest(const Message * message) throw()

Message * DefaultProviderManager::handleEnumerateInstanceNamesRequest(const Message * message)

{

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleEnumerateInstanceNamesRequest");

Line 431

Line 461

PEGASUS_ASSERT(request != 0);

CIMEnumerateInstanceNamesResponseMessage * response =

new CIMEnumerateInstanceNamesResponseMessage(

dynamic_cast<CIMEnumerateInstanceNamesResponseMessage*>(

request->messageId,

request->buildResponse());

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

EnumerateInstanceNamesResponseHandler handler(request, response);

EnumerateInstanceNamesResponseHandler handler(

request, response, _responseChunkCallback);

// process the request

try

{

Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,

PEG_LOGGER_TRACE((Logger::STANDARD_LOG, System::CIMSERVER,

"DefaultProviderManager::handleEnumerateInstanceNamesRequest - Host name: $0 Name space: $1 Class name: $2",

Logger::TRACE,

"DefaultProviderManager::handleEnumerateInstanceNamesRequest - "

"Host name: $0 Name space: $1 Class name: $2",

System::getHostName(),

request->nameSpace.getString(),

request->className.getString());

request->className.getString()));

// make target object path

CIMObjectPath objectPath(

Line 463

Line 486

request->nameSpace,

request->className);

// build an internal provider name from the request arguments

// resolve provider name

InternalProviderName name(

ProviderName name = _resolveProviderName(

String::EMPTY,

request->operationContext.get(ProviderIdContainer::NAME));

String::EMPTY,

objectPath.toString());

// resolve the physical and logical provider name

name = findProvider(name.toString());

// get cached or load new provider module

OpProviderHolder ph =

OpProviderHolder ph = providerManager.getProvider(

providerManager.getProvider(name.getPhysicalName(), name.getLogicalName());

name.getPhysicalName(), name.getLogicalName());

// convert arguments

OperationContext context;

context.insert(IdentityContainer(request->userName));

context.insert(request->operationContext.get(IdentityContainer::NAME));

context.insert(AcceptLanguageListContainer(request->acceptLanguages));

context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));

context.insert(ContentLanguageListContainer(request->contentLanguages));

context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));

// forward request

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

Line 490

Line 508

pm_service_op_lock op_lock(&ph.GetProvider());

STAT_GETSTARTTIME;

STAT_PMS_PROVIDERSTART;

ph.GetProvider().enumerateInstanceNames(

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.");

}

HandleCatch(handler);

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

return(response);

}

Message * DefaultProviderManager::handleCreateInstanceRequest(const Message * message) throw()

Message * DefaultProviderManager::handleCreateInstanceRequest(const Message * message)

{

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleCreateInstanceRequest");

Line 534

Line 535

// create response message

CIMCreateInstanceResponseMessage * response =

new CIMCreateInstanceResponseMessage(

dynamic_cast<CIMCreateInstanceResponseMessage*>(

request->messageId,

request->buildResponse());

CIMException(),

request->queueIds.copyAndPop(),

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

CreateInstanceResponseHandler handler(request, response);

CreateInstanceResponseHandler handler(

request, response, _responseChunkCallback);

try

{

Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,

PEG_LOGGER_TRACE((Logger::STANDARD_LOG, System::CIMSERVER,

"DefaultProviderManager::handleCreateInstanceRequest - Host name: $0 Name space: $1 Class name: $2",

Logger::TRACE,

"DefaultProviderManager::handleCreateInstanceRequest - "

"Host name: $0 Name space: $1 Class name: $2",

System::getHostName(),

request->nameSpace.getString(),

request->newInstance.getPath().getClassName().getString());

request->newInstance.getPath().getClassName().getString()));

// make target object path

CIMObjectPath objectPath(

Line 566

Line 560

request->newInstance.getPath().getClassName(),

request->newInstance.getPath().getKeyBindings());

InternalProviderName name(

// resolve provider name

String::EMPTY,

ProviderName name = _resolveProviderName(

String::EMPTY,

request->operationContext.get(ProviderIdContainer::NAME));

objectPath.toString());

name = findProvider(name.toString());

// get cached or load new provider module

OpProviderHolder ph =

OpProviderHolder ph = providerManager.getProvider(

providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);

name.getPhysicalName(), name.getLogicalName());

// convert arguments

OperationContext context;

context.insert(IdentityContainer(request->userName));

context.insert(request->operationContext.get(IdentityContainer::NAME));

context.insert(AcceptLanguageListContainer(request->acceptLanguages));

context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));

context.insert(ContentLanguageListContainer(request->contentLanguages));

context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));

// forward request

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

Line 591

Line 582

pm_service_op_lock op_lock(&ph.GetProvider());

STAT_GETSTARTTIME;

STAT_PMS_PROVIDERSTART;

ph.GetProvider().createInstance(

context,

objectPath,

request->newInstance,

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.");

}

HandleCatch(handler);

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

return(response);

}

Message * DefaultProviderManager::handleModifyInstanceRequest(const Message * message) throw()

Message * DefaultProviderManager::handleModifyInstanceRequest(const Message * message)

{

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleModifyInstanceRequest");

Line 636

Line 610

// create response message

CIMModifyInstanceResponseMessage * response =

new CIMModifyInstanceResponseMessage(

dynamic_cast<CIMModifyInstanceResponseMessage*>(

request->messageId,

request->buildResponse());

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

ModifyInstanceResponseHandler handler(request, response);

ModifyInstanceResponseHandler handler(

request, response, _responseChunkCallback);

try

{

Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,

PEG_LOGGER_TRACE((Logger::STANDARD_LOG, System::CIMSERVER,

"DefaultProviderManager::handleModifyInstanceRequest - Host name: $0 Name space: $1 Class name: $2",

Logger::TRACE,

"DefaultProviderManager::handleModifyInstanceRequest - "

"Host name: $0 Name space: $1 Class name: $2",

System::getHostName(),

request->nameSpace.getString(),

request->modifiedInstance.getPath().getClassName().getString());

request->modifiedInstance.getPath().getClassName().getString()));

// make target object path

CIMObjectPath objectPath(

Line 667

Line 635

request->modifiedInstance.getPath ().getClassName(),

request->modifiedInstance.getPath ().getKeyBindings());

InternalProviderName name(

// resolve provider name

String::EMPTY,

ProviderName name = _resolveProviderName(

String::EMPTY,

request->operationContext.get(ProviderIdContainer::NAME));

objectPath.toString());

name = findProvider(name.toString());

// get cached or load new provider module

OpProviderHolder ph =

OpProviderHolder ph = providerManager.getProvider(

providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);

name.getPhysicalName(), name.getLogicalName());

// convert arguments

OperationContext context;

context.insert(IdentityContainer(request->userName));

context.insert(request->operationContext.get(IdentityContainer::NAME));

context.insert(AcceptLanguageListContainer(request->acceptLanguages));

context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));

context.insert(ContentLanguageListContainer(request->contentLanguages));

context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));

CIMPropertyList propertyList(request->propertyList);

Line 694

Line 659

pm_service_op_lock op_lock(&ph.GetProvider());

STAT_GETSTARTTIME;

STAT_PMS_PROVIDERSTART;

ph.GetProvider().modifyInstance(

context,

Line 703

Line 668

request->includeQualifiers,

propertyList,

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.");

}

HandleCatch(handler);

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

return(response);

}

Message * DefaultProviderManager::handleDeleteInstanceRequest(const Message * message) throw()

Message * DefaultProviderManager::handleDeleteInstanceRequest(const Message * message)

{

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleDeleteInstanceRequest");

Line 741

Line 689

// create response message

CIMDeleteInstanceResponseMessage * response =

new CIMDeleteInstanceResponseMessage(

dynamic_cast<CIMDeleteInstanceResponseMessage*>(

request->messageId,

request->buildResponse());

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);

DeleteInstanceResponseHandler handler(

request, response, _responseChunkCallback);

try

{

Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,

PEG_LOGGER_TRACE((Logger::STANDARD_LOG, System::CIMSERVER,

"DefaultProviderManager::handleDeleteInstanceRequest - Host name: $0 Name space: $1 Class name: $2",

Logger::TRACE,

"DefaultProviderManager::handleDeleteInstanceRequest - "

"Host name: $0 Name space: $1 Class name: $2",

System::getHostName(),

request->nameSpace.getString(),

request->instanceName.getClassName().getString());

request->instanceName.getClassName().getString()));

// make target object path

CIMObjectPath objectPath(

Line 772

Line 714

request->instanceName.getClassName(),

request->instanceName.getKeyBindings());

InternalProviderName name(

// resolve provider name

String::EMPTY,

ProviderName name = _resolveProviderName(

String::EMPTY,

request->operationContext.get(ProviderIdContainer::NAME));

objectPath.toString());

name = findProvider(name.toString());

// get cached or load new provider module

OpProviderHolder ph =

OpProviderHolder ph = providerManager.getProvider(

providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);

name.getPhysicalName(), name.getLogicalName());

// convert arguments

OperationContext context;

context.insert(IdentityContainer(request->userName));

context.insert(request->operationContext.get(IdentityContainer::NAME));

context.insert(AcceptLanguageListContainer(request->acceptLanguages));

context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));

context.insert(ContentLanguageListContainer(request->contentLanguages));

context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));

// forward request

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

Line 797

Line 736

pm_service_op_lock op_lock(&ph.GetProvider());

STAT_GETSTARTTIME;

STAT_PMS_PROVIDERSTART;

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.");

}

HandleCatch(handler);

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

return(response);

}

Message * DefaultProviderManager::handleExecuteQueryRequest(const Message * message) throw()

Message * DefaultProviderManager::handleExecQueryRequest(const Message * message)

{

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleExecuteQueryRequest");

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleExecQueryRequest");

CIMExecQueryRequestMessage * request =

dynamic_cast<CIMExecQueryRequestMessage *>(const_cast<Message *>(message));

PEGASUS_ASSERT(request != 0);

//l10n

CIMExecQueryResponseMessage * response =

new CIMExecQueryResponseMessage(

dynamic_cast<CIMExecQueryResponseMessage*>(

request->messageId,

request->buildResponse());

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

// create a handler for this request

response->setKey(request->getKey());

ExecQueryResponseHandler handler(

request, response, _responseChunkCallback);

// Set HTTP method in response from request

try

response->setHttpMethod(request->getHttpMethod());

{

PEG_LOGGER_TRACE((Logger::STANDARD_LOG, System::CIMSERVER,

Logger::TRACE,

"DefaultProviderManager::handleExecQueryRequest - "

"Host name: $0 Name space: $1 Class name: $2",

System::getHostName(),

request->nameSpace.getString(),

request->className.getString()));

// l10n

// make target object path

// ATTN: when this is implemented, need to add the language containers to the

CIMObjectPath objectPath(

// OperationContext. See how the other requests do it.

System::getHostName(),

request->nameSpace,

request->className);

// 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());

if (dynamic_cast<CIMInstanceQueryProvider*>(ph.GetCIMProvider()) == 0) {

String errorString = " instance provider is registered supporting execQuery "

"but is not a CIMQueryInstanceProvider subclass.";

throw CIMException(CIM_ERR_FAILED,"ProviderLoadFailure (" + name.getPhysicalName() + ":" +

name.getLogicalName() + "):" + errorString);

}

// convert arguments

OperationContext context;

context.insert(request->operationContext.get(IdentityContainer::NAME));

context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));

context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));

QueryExpression qx(request->queryLanguage,request->query);

// forward request

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"Calling provider.executeQueryRequest: " +

ph.GetProvider().getName());

pm_service_op_lock op_lock(&ph.GetProvider());

STAT_PMS_PROVIDERSTART;

ph.GetProvider().execQuery(

context,

objectPath,

qx,

handler);

}

HandleCatch(handler);

PEG_METHOD_EXIT();

return(response);

}

Message * DefaultProviderManager::handleAssociatorsRequest(const Message * message) throw()

Message * DefaultProviderManager::handleAssociatorsRequest(const Message * message)

{

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleAssociatorsRequest");

Line 876

Line 842

PEGASUS_ASSERT(request != 0);

CIMAssociatorsResponseMessage * response =

new CIMAssociatorsResponseMessage(

dynamic_cast<CIMAssociatorsResponseMessage*>(

request->messageId,

request->buildResponse());

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);

AssociatorsResponseHandler handler(

request, response, _responseChunkCallback);

// process the request

try

{

Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,

PEG_LOGGER_TRACE((Logger::STANDARD_LOG, System::CIMSERVER,

"DefaultProviderManager::handleAssociatorsRequest - Host name: $0 Name space: $1 Class name: $2",

Logger::TRACE,

"DefaultProviderManager::handleAssociatorsRequest - "

"Host name: $0 Name space: $1 Class name: $2",

System::getHostName(),

request->nameSpace.getString(),

request->objectName.getClassName().getString());

request->objectName.getClassName().getString()));

// make target object path

CIMObjectPath objectPath(

Line 907

Line 869

objectPath.setKeyBindings(request->objectName.getKeyBindings());

// get the provider file name and logical name

CIMObjectPath assocPath(

Array<String> first;

System::getHostName(),

Array<String> second;

request->nameSpace,

Array<String> third;

request->assocClass.getString());

/* ATTN: temp disabled by Chip

// resolve provider name

getProviderRegistrar()->_lookupProviderForAssocClass(objectPath,

ProviderName name = _resolveProviderName(

// request->associationClass,

request->operationContext.get(ProviderIdContainer::NAME));

// request->resultClass,

CIMName(),

first, second, third);

for(Uint32 i=0,n=first.size(); i<n; i++)

{

// get cached or load new provider module

OpProviderHolder ph =

OpProviderHolder ph = providerManager.getProvider(

providerManager.getProvider(first[i], second[i], third[i]);

name.getPhysicalName(), name.getLogicalName());

// convert arguments

OperationContext context;

context.insert(IdentityContainer(request->userName));

context.insert(request->operationContext.get(IdentityContainer::NAME));

context.insert(AcceptLanguageListContainer(request->acceptLanguages));

context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));

context.insert(ContentLanguageListContainer(request->contentLanguages));

context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));

// ATTN KS STAT_GETSTARTTIME;

STAT_PMS_PROVIDERSTART;

pm_service_op_lock op_lock(&ph.GetProvider());

ph.GetProvider().associators(

Line 946

Line 901

request->resultRole,

request->includeQualifiers,

request->includeClassOrigin,

request->propertyList.getPropertyNameArray(),

request->propertyList,

handler);

}

HandleCatch(handler);

STAT_PMS_PROVIDEREND;

PEG_METHOD_EXIT();

} // end for loop

STAT_COPYDISPATCHER

}

catch(CIMException & e)

return(response);

{

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"Exception: " + e.getMessage());

handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n

}

catch(Exception & e)

{

Message * DefaultProviderManager::handleAssociatorNamesRequest(const Message * message)

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");

Line 987

Line 923

PEGASUS_ASSERT(request != 0);

CIMAssociatorNamesResponseMessage * response =

new CIMAssociatorNamesResponseMessage(

dynamic_cast<CIMAssociatorNamesResponseMessage*>(

request->messageId,

request->buildResponse());

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);

AssociatorNamesResponseHandler handler(

request, response, _responseChunkCallback);

// process the request

try

{

Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,

PEG_LOGGER_TRACE((Logger::STANDARD_LOG, System::CIMSERVER,

"DefaultProviderManager::handleAssociationNamesRequest - Host name: $0 Name space: $1 Class name: $2",

Logger::TRACE,

"DefaultProviderManager::handleAssociationNamesRequest - "

"Host name: $0 Name space: $1 Class name: $2",

System::getHostName(),

request->nameSpace.getString(),

request->objectName.getClassName().getString());

request->objectName.getClassName().getString()));

// make target object path

CIMObjectPath objectPath(

Line 1021

Line 950

objectPath.setKeyBindings(request->objectName.getKeyBindings());

// get the provider file name and logical name

CIMObjectPath assocPath(

Array<String> first;

System::getHostName(),

Array<String> second;

request->nameSpace,

Array<String> third;

request->assocClass.getString());

/* temp disabled by Chip

// resolve provider name

getProviderRegistrar()->_lookupProviderForAssocClass(objectPath,

ProviderName name = _resolveProviderName(

// request->associationClass,

request->operationContext.get(ProviderIdContainer::NAME));

// request->resultClass,

CIMName(),

first, second, third);

for(Uint32 i=0,n=first.size(); i<n; i++)

{

// get cached or load new provider module

OpProviderHolder ph =

OpProviderHolder ph = providerManager.getProvider(

providerManager.getProvider(first[i], second[i], third[i]);

name.getPhysicalName(), name.getLogicalName());

// convert arguments

OperationContext context;

context.insert(IdentityContainer(request->userName));

context.insert(request->operationContext.get(IdentityContainer::NAME));

context.insert(AcceptLanguageListContainer(request->acceptLanguages));

context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));

context.insert(ContentLanguageListContainer(request->contentLanguages));

context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));

STAT_PMS_PROVIDERSTART;

pm_service_op_lock op_lock(&ph.GetProvider());

ph.GetProvider().associatorNames(

Line 1058

Line 981

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.");

}

HandleCatch(handler);

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

return(response);

}

Message * DefaultProviderManager::handleReferencesRequest(const Message * message) throw()

Message * DefaultProviderManager::handleReferencesRequest(const Message * message)

{

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleReferencesRequest");

Line 1093

Line 1001

PEGASUS_ASSERT(request != 0);

CIMReferencesResponseMessage * response =

new CIMReferencesResponseMessage(

dynamic_cast<CIMReferencesResponseMessage*>(

request->messageId,

request->buildResponse());

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);

ReferencesResponseHandler handler(

request, response, _responseChunkCallback);

// process the request

try

{

Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,

PEG_LOGGER_TRACE((Logger::STANDARD_LOG, System::CIMSERVER,

"DefaultProviderManager::handleReferencesRequest - Host name: $0 Name space: $1 Class name: $2",

Logger::TRACE,

"DefaultProviderManager::handleReferencesRequest - "

"Host name: $0 Name space: $1 Class name: $2",

System::getHostName(),

request->nameSpace.getString(),

request->objectName.getClassName().getString());

request->objectName.getClassName().getString()));

// make target object path

CIMObjectPath objectPath(

Line 1127

Line 1028

objectPath.setKeyBindings(request->objectName.getKeyBindings());

// get the provider file name and logical name

CIMObjectPath resultPath(

Array<String> first;

System::getHostName(),

Array<String> second;

request->nameSpace,

Array<String> third;

request->resultClass.getString());

/* temp disabled by Chip

// resolve provider name

getProviderRegistrar()->_lookupProviderForAssocClass(objectPath,

ProviderName name = _resolveProviderName(

// request->associationClass,

request->operationContext.get(ProviderIdContainer::NAME));

// request->resultClass,

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(

OpProviderHolder ph =

name.getPhysicalName(), name.getLogicalName());

providerManager.getProvider(first[i], second[i], third[i]);

// convert arguments

OperationContext context;

context.insert(IdentityContainer(request->userName));

context.insert(request->operationContext.get(IdentityContainer::NAME));

context.insert(AcceptLanguageListContainer(request->acceptLanguages));

context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));

context.insert(ContentLanguageListContainer(request->contentLanguages));

context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));

STAT_GETSTARTTIME;

STAT_PMS_PROVIDERSTART;

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"Calling provider.references: " +

Line 1170

Line 1063

request->role,

request->includeQualifiers,

request->includeClassOrigin,

request->propertyList.getPropertyNameArray(),

request->propertyList,

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.");

}

HandleCatch(handler);

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

return(response);

}

Message * DefaultProviderManager::handleReferenceNamesRequest(const Message * message) throw()

Message * DefaultProviderManager::handleReferenceNamesRequest(const Message * message)

{

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleReferenceNamesRequest");

Line 1211

Line 1085

PEGASUS_ASSERT(request != 0);

CIMReferenceNamesResponseMessage * response =

new CIMReferenceNamesResponseMessage(

dynamic_cast<CIMReferenceNamesResponseMessage*>(

request->messageId,

request->buildResponse());

CIMException(),

PEGASUS_ASSERT(response != 0);

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);

ReferenceNamesResponseHandler handler(

request, response, _responseChunkCallback);

// process the request

try

{

Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,

PEG_LOGGER_TRACE((Logger::STANDARD_LOG, System::CIMSERVER,

"DefaultProviderManager::handleReferenceNamesRequest - Host name: $0 Name space: $1 Class name: $2",

Logger::TRACE,

"DefaultProviderManager::handleReferenceNamesRequest - "

"Host name: $0 Name space: $1 Class name: $2",

System::getHostName(),

request->nameSpace.getString(),

request->objectName.getClassName().getString());

request->objectName.getClassName().getString()));

// make target object path

CIMObjectPath objectPath(

Line 1243

Line 1112

objectPath.setKeyBindings(request->objectName.getKeyBindings());

// get the provider file name and logical name

CIMObjectPath resultPath(

Array<String> first;

System::getHostName(),

Array<String> second;

request->nameSpace,

Array<String> third;

request->resultClass.getString());

/* temp disabled by Chip

// resolve provider name

getProviderRegistrar()->_lookupProviderForAssocClass(objectPath,

ProviderName name = _resolveProviderName(

// request->associationClass,

request->operationContext.get(ProviderIdContainer::NAME));

// request->resultClass,

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(

OpProviderHolder ph =

name.getPhysicalName(), name.getLogicalName());

providerManager.getProvider(first[i], second[i], third[i]);

// convert arguments

OperationContext context;

context.insert(IdentityContainer(request->userName));

context.insert(request->operationContext.get(IdentityContainer::NAME));

context.insert(AcceptLanguageListContainer(request->acceptLanguages));

context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));

context.insert(ContentLanguageListContainer(request->contentLanguages));

context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));

STAT_GETSTARTTIME;

STAT_PMS_PROVIDERSTART;

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"Calling provider.referenceNames: " +

Line 1285

Line 1146

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.");

}

HandleCatch(handler);

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

return(response);

}

Message * DefaultProviderManager::handleGetPropertyRequest(const Message * message) throw()

Message * DefaultProviderManager::handleGetPropertyRequest(const Message * message)

{

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleGetPropertyRequest");

Line 1325

Line 1167

// create response message

CIMGetPropertyResponseMessage * response =

new CIMGetPropertyResponseMessage(

dynamic_cast<CIMGetPropertyResponseMessage*>(

request->messageId,

request->buildResponse());

CIMException(),

request->queueIds.copyAndPop(),

CIMValue());

PEGASUS_ASSERT(response != 0);

// preserve message key

GetPropertyResponseHandler handler(

response->setKey(request->getKey());

request, response, _responseChunkCallback);

// 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,

PEG_LOGGER_TRACE((Logger::STANDARD_LOG, System::CIMSERVER,

"DefaultProviderManager::handleGetPropertyRequest - Host name: $0 Name space: $1 Class name: $2",

Logger::TRACE,

"DefaultProviderManager::handleGetPropertyRequest - "

"Host name: $0 Name space: $1 Class name: $2",

System::getHostName(),

request->nameSpace.getString(),

request->instanceName.getClassName().getString());

request->instanceName.getClassName().getString()));

// make target object path

CIMObjectPath objectPath(

Line 1356

Line 1191

request->instanceName.getClassName(),

request->instanceName.getKeyBindings());

InternalProviderName name(

// resolve provider name

String::EMPTY,

ProviderName name = _resolveProviderName(

String::EMPTY,

request->operationContext.get(ProviderIdContainer::NAME));

objectPath.toString());

name = findProvider(name.toString());

// get cached or load new provider module

OpProviderHolder ph =

OpProviderHolder ph = providerManager.getProvider(

providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);

name.getPhysicalName(), name.getLogicalName());

// convert arguments

OperationContext context;

context.insert(IdentityContainer(request->userName));

context.insert(request->operationContext.get(IdentityContainer::NAME));

context.insert(AcceptLanguageListContainer(request->acceptLanguages));

context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));

context.insert(ContentLanguageListContainer(request->contentLanguages));

context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));

CIMName propertyName = request->propertyName;

STAT_GETSTARTTIME;

STAT_PMS_PROVIDERSTART;

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"Calling provider.getProperty: " +

Line 1390

Line 1222

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.");

}

HandleCatch(handler);

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

return(response);

}

Message * DefaultProviderManager::handleSetPropertyRequest(const Message * message) throw()

Message * DefaultProviderManager::handleSetPropertyRequest(const Message * message)

{

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleSetPropertyRequest");

Line 1427

Line 1242

PEGASUS_ASSERT(request != 0);

// create response message

//l10n

CIMSetPropertyResponseMessage * response =

new CIMSetPropertyResponseMessage(

dynamic_cast<CIMSetPropertyResponseMessage*>(

request->messageId,

request->buildResponse());

PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, MessageLoaderParms(

"ProviderManager.DefaultProviderManager.NOT_IMPLEMENTED",

"not implemented")),

request->queueIds.copyAndPop());

PEGASUS_ASSERT(response != 0);

// preserve message key

SetPropertyResponseHandler handler(

response->setKey(request->getKey());

request, response, _responseChunkCallback);

// 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,

PEG_LOGGER_TRACE((Logger::STANDARD_LOG, System::CIMSERVER,

"DefaultProviderManager::handleSetPropertyRequest - Host name: $0 Name space: $1 Class name: $2",

Logger::TRACE,

"DefaultProviderManager::handleSetPropertyRequest - "

"Host name: $0 Name space: $1 Class name: $2",

System::getHostName(),

request->nameSpace.getString(),

request->instanceName.getClassName().getString());

request->instanceName.getClassName().getString()));

// make target object path

CIMObjectPath objectPath(

Line 1461

Line 1267

request->instanceName.getClassName(),

request->instanceName.getKeyBindings());

InternalProviderName name(

// resolve provider name

String::EMPTY,

ProviderName name = _resolveProviderName(

String::EMPTY,

request->operationContext.get(ProviderIdContainer::NAME));

objectPath.toString());

name = findProvider(name.toString());

// get cached or load new provider module

OpProviderHolder ph =

OpProviderHolder ph = providerManager.getProvider(

providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);

name.getPhysicalName(), name.getLogicalName());

// convert arguments

OperationContext context;

context.insert(IdentityContainer(request->userName));

context.insert(request->operationContext.get(IdentityContainer::NAME));

context.insert(AcceptLanguageListContainer(request->acceptLanguages));

context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));

context.insert(ContentLanguageListContainer(request->contentLanguages));

context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));

CIMName propertyName = request->propertyName;

CIMValue propertyValue = request->newValue;

STAT_GETSTARTTIME;

STAT_PMS_PROVIDERSTART;

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"Calling provider.setProperty: " +

Line 1497

Line 1300

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.");

}

HandleCatch(handler);

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

return(response);

}

Message * DefaultProviderManager::handleInvokeMethodRequest(const Message * message) throw()

Message * DefaultProviderManager::handleInvokeMethodRequest(const Message * message)

{

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleInvokeMethodRequest");

Line 1535

Line 1321

// create response message

CIMInvokeMethodResponseMessage * response =

new CIMInvokeMethodResponseMessage(

dynamic_cast<CIMInvokeMethodResponseMessage*>(

request->messageId,

request->buildResponse());

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);

InvokeMethodResponseHandler handler(

request, response, _responseChunkCallback);

try

{

Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,

PEG_LOGGER_TRACE((Logger::STANDARD_LOG, System::CIMSERVER,

"DefaultProviderManager::handleInvokeMethodRequest - Host name: $0 Name space: $1 Class name: $2",

Logger::TRACE,

"DefaultProviderManager::handleInvokeMethodRequest - "

"Host name: $0 Name space: $1 Class name: $2",

System::getHostName(),

request->nameSpace.getString(),

request->instanceName.getClassName().getString());

request->instanceName.getClassName().getString()));

// make target object path

CIMObjectPath objectPath(

Line 1569

Line 1346

request->instanceName.getClassName(),

request->instanceName.getKeyBindings());

InternalProviderName name(

// resolve provider name

String::EMPTY,

ProviderName name = _resolveProviderName(

String::EMPTY,

request->operationContext.get(ProviderIdContainer::NAME));

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(

OpProviderHolder ph =

name.getPhysicalName(), name.getLogicalName());

providerManager.getProvider(triad.first, triad.second, triad.third);

// convert arguments

OperationContext context;

context.insert(IdentityContainer(request->userName));

context.insert(request->operationContext.get(IdentityContainer::NAME));

context.insert(AcceptLanguageListContainer(request->acceptLanguages));

context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));

context.insert(ContentLanguageListContainer(request->contentLanguages));

context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));

CIMObjectPath instanceReference(request->instanceName);

// ATTN: propagate namespace

instanceReference.setNameSpace(request->nameSpace);

// forward request

STAT_GETSTARTTIME;

STAT_PMS_PROVIDERSTART;

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"Calling provider.invokeMethod: " +

Line 1614

Line 1372

ph.GetProvider().invokeMethod(

context,

instanceReference,

objectPath,

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.");

}

HandleCatch(handler);

PEG_METHOD_EXIT();

return(response);

}

Message * DefaultProviderManager::handleCreateSubscriptionRequest(const Message * message) throw()

Message * DefaultProviderManager::handleCreateSubscriptionRequest(const Message * message)

{

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleCreateSubscriptionRequest");

Line 1655

Line 1394

PEGASUS_ASSERT(request != 0);

CIMCreateSubscriptionResponseMessage * response =

new CIMCreateSubscriptionResponseMessage(

dynamic_cast<CIMCreateSubscriptionResponseMessage*>(

request->messageId,

request->buildResponse());

CIMException(),

request->queueIds.copyAndPop());

PEGASUS_ASSERT(response != 0);

// preserve message key

OperationResponseHandler handler(

response->setKey(request->getKey());

request, response, _responseChunkCallback);

// Set HTTP method in response from request

try

response->setHttpMethod (request->getHttpMethod ());

{

String temp;

OperationResponseHandler handler(request, response);

for(Uint32 i = 0, n = request->classNames.size(); i < n; i++)

{

temp.append(request->classNames[i].getString());

try

if(i == (n - 1))

{

InternalProviderName name("");

temp.append(", ");

}

/* temp disabled by Chip

PEG_LOGGER_TRACE((Logger::STANDARD_LOG, System::CIMSERVER,

InternalProviderName name(

Logger::TRACE,

String::EMPTY,

"DefaultProviderManager::handleCreateSubscriptionRequest - "

String::EMPTY,

"Host name: $0 Name space: $1 Class name(s): $2",

objectPath.toString());

System::getHostName(),

request->nameSpace.getString(),

temp));

name = findProvider(name.toString());

CIMInstance req_provider, req_providerModule;

ProviderIdContainer pidc = (ProviderIdContainer)request->operationContext.get(ProviderIdContainer::NAME);

req_provider = pidc.getProvider();

req_providerModule = pidc.getModule();

// get cached or load new provider module

String physicalName=_resolvePhysicalName( req_providerModule.getProperty(

OpProviderHolder ph =

req_providerModule.findProperty("Location")).getValue().toString());

providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);

ProviderName name(req_provider.getProperty(req_provider.findProperty("Name")).getValue ().toString (),

// get the provider file name and logical name

physicalName,

Triad<String, String, String> triad =

req_providerModule.getProperty(req_providerModule.findProperty

getProviderRegistrar()->_getProviderRegPair(request->provider, request->providerModule);

("InterfaceType")).getValue().toString(),

0);

// get cached or load new provider module

OpProviderHolder ph =

OpProviderHolder ph = providerManager.getProvider(

providerManager.getProvider(triad.first, triad.second, triad.third);

name.getPhysicalName(), name.getLogicalName());

// Save the provider instance from the request

ph.GetProvider ().setProviderInstance (req_provider);

// convert arguments

OperationContext context;

context.insert(IdentityContainer(request->userName));

context.insert(request->operationContext.get(IdentityContainer::NAME));

context.insert(SubscriptionInstanceContainer

context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));

(request->subscriptionInstance));

context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));

context.insert(SubscriptionFilterConditionContainer

context.insert(request->operationContext.get(SubscriptionInstanceContainer::NAME));

(request->condition, request->queryLanguage));

context.insert(request->operationContext.get(SubscriptionFilterConditionContainer::NAME));

context.insert(SubscriptionLanguageListContainer

context.insert(request->operationContext.get(SubscriptionFilterQueryContainer::NAME));

(request->acceptLanguages));

context.insert(AcceptLanguageListContainer(request->acceptLanguages));

context.insert(ContentLanguageListContainer(request->contentLanguages));

CIMObjectPath subscriptionName = request->subscriptionInstance.getPath();

Line 1721

Line 1467

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);

}

Line 1746

Line 1486

classNames,

propertyList,

repeatNotificationPolicy);

// Increment count of current subscriptions for this provider

if (ph.GetProvider ().testIfZeroAndIncrementSubscriptions ())

{

// If there were no current subscriptions before the increment,

// the first subscription has been created

// Call the provider's enableIndications method

if (_subscriptionInitComplete)

{

_callEnableIndications (req_provider,

_indicationCallback, ph);

}

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");

}

Line 1771

Line 1531

return(response);

}

Message * DefaultProviderManager::handleModifySubscriptionRequest( const Message * message) throw()

Message * DefaultProviderManager::handleModifySubscriptionRequest( const Message * message)

{

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleModifySubscriptionRequest");

Line 1781

Line 1541

PEGASUS_ASSERT(request != 0);

CIMModifySubscriptionResponseMessage * response =

new CIMModifySubscriptionResponseMessage(

dynamic_cast<CIMModifySubscriptionResponseMessage*>(

request->messageId,

request->buildResponse());

CIMException(),

request->queueIds.copyAndPop());

PEGASUS_ASSERT(response != 0);

// preserve message key

OperationResponseHandler handler(

response->setKey(request->getKey());

request, response, _responseChunkCallback);

// Set HTTP method in response from request

try

response->setHttpMethod (request->getHttpMethod ());

{

String temp;

OperationResponseHandler handler(request, response);

for(Uint32 i = 0, n = request->classNames.size(); i < n; i++)

{

temp.append(request->classNames[i].getString());

try

if(i == (n - 1))

{

InternalProviderName name("");

temp.append(", ");

}

PEG_LOGGER_TRACE((Logger::STANDARD_LOG, System::CIMSERVER,

InternalProviderName name(

Logger::TRACE,

String::EMPTY,

"DefaultProviderManager::handleCreateSubscriptionRequest - "

String::EMPTY,

"Host name: $0 Name space: $1 Class name(s): $2",

objectPath.toString());

System::getHostName(),

request->nameSpace.getString(),

temp));

name = findProvider(name.toString());

CIMInstance req_provider, req_providerModule;

ProviderIdContainer pidc = (ProviderIdContainer)request->operationContext.get(ProviderIdContainer::NAME);

req_provider = pidc.getProvider();

req_providerModule = pidc.getModule();

// get cached or load new provider module

String physicalName=_resolvePhysicalName( req_providerModule.getProperty(

OpProviderHolder ph =

req_providerModule.findProperty("Location")).getValue().toString());

providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);

ProviderName name(req_provider.getProperty(req_provider.findProperty("Name")).getValue ().toString (),

// get the provider file name and logical name

physicalName,

Triad<String, String, String> triad =

req_providerModule.getProperty(req_providerModule.findProperty

getProviderRegistrar()->_getProviderRegPair(request->provider, request->providerModule);

("InterfaceType")).getValue().toString(),

0);

// get cached or load new provider module

//Provider provider =

OpProviderHolder ph = providerManager.getProvider(

OpProviderHolder ph =

name.getPhysicalName(), name.getLogicalName());

providerManager.getProvider(triad.first, triad.second, triad.third);

// convert arguments

OperationContext context;

context.insert(request->operationContext.get(IdentityContainer::NAME));

context.insert(IdentityContainer(request->userName));

context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));

context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));

context.insert(SubscriptionInstanceContainer

context.insert(request->operationContext.get(SubscriptionInstanceContainer::NAME));

(request->subscriptionInstance));

context.insert(request->operationContext.get(SubscriptionFilterConditionContainer::NAME));

context.insert(SubscriptionFilterConditionContainer

context.insert(request->operationContext.get(SubscriptionFilterQueryContainer::NAME));

(request->condition, request->queryLanguage));

context.insert(SubscriptionLanguageListContainer

(request->acceptLanguages));

context.insert(AcceptLanguageListContainer(request->acceptLanguages));

context.insert(ContentLanguageListContainer(request->contentLanguages));

CIMObjectPath subscriptionName = request->subscriptionInstance.getPath();

Line 1849

Line 1608

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);

}

Line 1879

Line 1632

{

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");

}

Line 1899

Line 1655

return(response);

}

Message * DefaultProviderManager::handleDeleteSubscriptionRequest(const Message * message) throw()

Message * DefaultProviderManager::handleDeleteSubscriptionRequest(const Message * message)

{

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleDeleteSubscriptionRequest");

Line 1909

Line 1665

PEGASUS_ASSERT(request != 0);

CIMDeleteSubscriptionResponseMessage * response =

new CIMDeleteSubscriptionResponseMessage(

dynamic_cast<CIMDeleteSubscriptionResponseMessage*>(

request->messageId,

request->buildResponse());

CIMException(),

request->queueIds.copyAndPop());

PEGASUS_ASSERT(response != 0);

// preserve message key

OperationResponseHandler handler(

response->setKey(request->getKey());

request, response, _responseChunkCallback);

// Set HTTP method in response from request

try

response->setHttpMethod(request->getHttpMethod());

{

String temp;

OperationResponseHandler handler(request, response);

for(Uint32 i = 0, n = request->classNames.size(); i < n; i++)

{

temp.append(request->classNames[i].getString());

try

if(i == (n - 1))

{

InternalProviderName name("");

temp.append(", ");

}

PEG_LOGGER_TRACE((Logger::STANDARD_LOG, System::CIMSERVER,

InternalProviderName name(

Logger::TRACE,

String::EMPTY,

"DefaultProviderManager::handleDeleteSubscriptionRequest - "

String::EMPTY,

"Host name: $0 Name space: $1 Class name(s): $2",

objectPath.toString());

System::getHostName(),

request->nameSpace.getString(),

temp));

name = findProvider(name.toString());

CIMInstance req_provider, req_providerModule;

ProviderIdContainer pidc = (ProviderIdContainer)request->operationContext.get(ProviderIdContainer::NAME);

// get cached or load new provider module

req_provider = pidc.getProvider();

OpProviderHolder ph =

req_providerModule = pidc.getModule();

providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);

String physicalName=_resolvePhysicalName( req_providerModule.getProperty(

req_providerModule.findProperty("Location")).getValue().toString());

ProviderName name(req_provider.getProperty(req_provider.findProperty("Name")).getValue ().toString (),

// get the provider file name and logical name

physicalName,

Triad<String, String, String> triad =

req_providerModule.getProperty(req_providerModule.findProperty

getProviderRegistrar()->_getProviderRegPair(request->provider, request->providerModule);

("InterfaceType")).getValue().toString(),

0);

// get cached or load new provider module

//Provider provider =

OpProviderHolder ph = providerManager.getProvider(

OpProviderHolder ph =

name.getPhysicalName(), name.getLogicalName());

providerManager.getProvider(triad.first, triad.second, triad.third);

// convert arguments

OperationContext context;

context.insert(IdentityContainer(request->userName));

context.insert(request->operationContext.get(IdentityContainer::NAME));

context.insert(SubscriptionInstanceContainer

context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));

(request->subscriptionInstance));

context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));

context.insert(SubscriptionLanguageListContainer

context.insert(request->operationContext.get(SubscriptionInstanceContainer::NAME));

(request->acceptLanguages));

context.insert(AcceptLanguageListContainer(request->acceptLanguages));

context.insert(ContentLanguageListContainer(request->contentLanguages));

CIMObjectPath subscriptionName = request->subscriptionInstance.getPath();

Line 1974

Line 1732

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);

}

Line 1993

Line 1745

context,

subscriptionName,

classNames);

}

catch(CIMException & e)

// Decrement count of current subscriptions for this provider

if (ph.GetProvider ().decrementSubscriptionsAndTestIfZero ())

{

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"Exception: " + e.getMessage());

// If there are no current subscriptions after the decrement,

handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n

// the last subscription has been deleted

}

// Call the provider's disableIndications method

catch(Exception & e)

{

if (_subscriptionInitComplete)

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::handleEnableIndicationsRequest(const Message * message) throw()

{

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager:: handleEnableIndicationsRequest");

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);

// preserve message key

response->setKey(request->getKey());

// Set HTTP method in response from request

response->setHttpMethod(request->getHttpMethod());

response->dest = request->queueIds.top();

// ATTN: need pointer to Provider Manager Server!

//EnableIndicationsResponseHandler *handler =

// new EnableIndicationsResponseHandler(request, response, this);

try

{

// get the provider file name and logical name

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,

"Calling provider.enableIndications: " +

ph.GetProvider().getName());

ph.GetProvider().protect();

ph.GetProvider().enableIndications(*handler);

// if no exception, store the handler so it is persistent for as

// long as the provider has indications enabled.

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"Storing indication handler for " + ph.GetProvider().getName());

_insertEntry(ph.GetProvider(), handler);

}

catch(CIMException & e)

{

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"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(...)

{

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"Exception: Unknown");

//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();

return(response);

}

Message * DefaultProviderManager::handleDisableIndicationsRequest(const Message * message) throw()

{

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleDisableIndicationsRequest");

CIMDisableIndicationsRequestMessage * request =

dynamic_cast<CIMDisableIndicationsRequestMessage *>(const_cast<Message *>(message));

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);

try

{

InternalProviderName name("");

InternalProviderName name(

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,

"Calling provider.disableIndications: " +

ph.GetProvider().getName());

Line 2173

Line 1766

ph.GetProvider().unprotect();

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"Removing and Destroying indication handler for " +

ph.GetProvider().getName());

delete _removeEntry(_generateKey(ph.GetProvider()));

}

catch(CIMException & e)

{

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"Exception: " + e.getMessage());

response->cimException = CIMException(e);

handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n

}

catch(Exception & e)

{

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"Exception: " + e.getMessage());

//l10n

//response->cimException = CIMException(CIM_ERR_FAILED, "Internal Error");

handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n

response->cimException = CIMException(CIM_ERR_FAILED, MessageLoaderParms(

"ProviderManager.DefaultProviderManager.INTERNAL_ERROR",

"Internal Error"));

}

catch(...)

{

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"Exception: Unknown");

//l10n

//response->cimException = CIMException(CIM_ERR_FAILED, "Unknown Error");

handler.setStatus(CIM_ERR_FAILED, "Unknown Error");

response->cimException = CIMException(CIM_ERR_FAILED, MessageLoaderParms(

"ProviderManager.DefaultProviderManager.UNKNOWN_ERROR",

"Unknown Error"));

}

PEG_METHOD_EXIT();

Line 2212

Line 1804

return(response);

}

Message * DefaultProviderManager::handleConsumeIndicationRequest(const Message *message) throw()

Message *DefaultProviderManager::handleExportIndicationRequest(const Message *message)

{

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handlConsumeIndicationRequest");

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManagerService::handlExportIndicationRequest");

CIMConsumeIndicationRequestMessage *request =

CIMExportIndicationRequestMessage * request =

dynamic_cast<CIMConsumeIndicationRequestMessage *>(const_cast<Message *>(message));

dynamic_cast<CIMExportIndicationRequestMessage *>(const_cast<Message *>(message));

PEGASUS_ASSERT(request != 0);

CIMResponseMessage * response =

CIMExportIndicationResponseMessage* response =

new CIMResponseMessage(

dynamic_cast<CIMExportIndicationResponseMessage*>(

CIM_CONSUME_INDICATION_RESPONSE_MESSAGE,

request->buildResponse());

request->messageId,

CIMException(),

request->queueIds.copyAndPop());

PEGASUS_ASSERT(response != 0);

response->setKey(request->getKey());

OperationResponseHandler handler(

request, response, _responseChunkCallback);

// Set HTTP method in response from request

response->setHttpMethod (request->getHttpMethod ());

Uint32 type = 3;

try

{

InternalProviderName name("");

// resolve provider name

ProviderName name = _resolveProviderName(

request->operationContext.get(ProviderIdContainer::NAME));

InternalProviderName name(

String::EMPTY,

objectPath.toString());

name = findProvider(name.toString());

// get cached or load new provider module

OpProviderHolder ph =

OpProviderHolder ph = providerManager.getProvider(

providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);

name.getPhysicalName(), name.getLogicalName());

STAT_PMS_PROVIDERSTART

// get the provider file name and logical name

Triad<String, String, String> triad =

getProviderRegistrar()->_getProviderRegPair(request->consumer_provider, request->consumer_module);

// 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,

"Calling provider.: " +

Line 2271

Line 1839

OperationContext context;

context.insert(request->operationContext.get(IdentityContainer::NAME));

//L10N_TODO

//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;

context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));

SimpleIndicationResponseHandler handler;

CIMInstance indication_copy = request->indicationInstance;

pm_service_op_lock op_lock(&ph.GetProvider());

ph.GetProvider().consumeIndication(context,

"",

request->destinationPath,

indication_copy);

}

catch(CIMException & e)

HandleCatch(handler);

{

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"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(...)

{

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"Exception: Unknown");

//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();

return(response);

}

// This function disables a provider module if disableProviderOnly is not true,

// otherwise, disables a provider. Disable provider module means that

Line 2328

Line 1877

// ATTN-YZ-P2-20030519: Provider needs to be blocked when disable a provider.

Message * DefaultProviderManager::handleDisableModuleRequest(const Message * message) throw()

Message * DefaultProviderManager::handleDisableModuleRequest(const Message * message)

{

// HACK

ProviderRegistrationManager * _providerRegistrationManager = ProviderManager::getProviderRegistrationManager();

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleDisableModuleRequest");

CIMDisableModuleRequestMessage * request =

Line 2340

Line 1886

PEGASUS_ASSERT(request != 0);

Array<Uint16> operationalStatus;

CIMException cimException;

try

{

// get provider module name

String moduleName;

CIMInstance mInstance = request->providerModule;

Uint32 pos = mInstance.findProperty(CIMName ("Name"));

PEGASUS_ASSERT(pos != PEG_NOT_FOUND);

if(pos != PEG_NOT_FOUND)

{

mInstance.getProperty(pos).getValue().get(moduleName);

}

Boolean disableProviderOnly = request->disableProviderOnly;

// get operational status

// Unload providers

Array<Uint16> operationalStatus;

Array<CIMInstance> _pInstances = request->providers;

Array<Boolean> _indicationProviders = request->indicationProviders;

String physicalName=_resolvePhysicalName(

mInstance.getProperty(

mInstance.findProperty("Location")).getValue().toString());

for(Uint32 i = 0, n = _pInstances.size(); i < n; i++)

{

String pName(_pInstances[i].getProperty(

_pInstances[i].findProperty("Name")).getValue().toString());

Sint16 ret_value = providerManager.disableProvider(pName);

if(!disableProviderOnly)

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) // Success

{

Uint32 pos2 = mInstance.findProperty(CIMName ("OperationalStatus"));

if (_indicationProviders[i])

if(pos2 != PEG_NOT_FOUND)

{

// ATTN-CAKG-P2-20020821: Check for null status?

// If it is an indication provider

// remove the entry from the table since the

// provider has been disabled

mInstance.getProperty(pos2).getValue().get(operationalStatus);

delete _removeEntry(_generateKey(pName,physicalName));

}

else

// 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);

// 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."));

}

operationalStatus.append(_MODULE_STOPPING);

}

catch(CIMException & e)

if(_providerRegistrationManager->setProviderModuleStatus

(moduleName, operationalStatus) == false)

{

//l10n

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, "set module status failed.");

"Exception: " + e.getMessage());

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, MessageLoaderParms(

cimException = e;

"ProviderManager.DefaultProviderManager.SET_MODULE_STATUS_FAILED",

"set module status failed."));

}

catch(Exception & e)

{

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"Exception: " + e.getMessage());

cimException = CIMException(CIM_ERR_FAILED, e.getMessage());

}

catch(...)

// Unload providers

Array<CIMInstance> _pInstances = request->providers;

for(Uint32 i = 0, n = _pInstances.size(); i < n; i++)

{

/* temp disabled by Chip

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

// get the provider file name and logical name

"Exception: Unknown");

Triad<String, String, String> triad =

//l10n

getProviderRegistrar()->_getProviderRegPair(_pInstances[i], mInstance);

//response->cimException = CIMException(CIM_ERR_FAILED, "Unknown Error");

cimException = PEGASUS_CIM_EXCEPTION_L(

providerManager.unloadProvider(triad.first, triad.second);

CIM_ERR_FAILED,

MessageLoaderParms(

"ProviderManager.ProviderManagerService.UNKNOWN_ERROR",

"Unknown Error"));

}

if(!disableProviderOnly)

if (cimException.getCode() == CIM_ERR_SUCCESS)

{

// update module status from Stopping to Stopped

for(Uint32 i=0, n = operationalStatus.size(); i < n; i++)

{

if(operationalStatus[i] == _MODULE_STOPPING)

// Status is set to OK if a provider was busy

if (operationalStatus.size() == 0)

{

operationalStatus.remove(i);

operationalStatus.append(CIM_MSE_OPSTATUS_VALUE_STOPPED);

}

operationalStatus.append(_MODULE_STOPPED);

else

if(_providerRegistrationManager->setProviderModuleStatus

(moduleName, operationalStatus) == false)

{

//l10n

// If exception occurs, module is not stopped

//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,

operationalStatus.append(CIM_MSE_OPSTATUS_VALUE_OK);

//"set module status failed.");

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, MessageLoaderParms(

"ProviderManager.DefaultProviderManager.SET_MODULE_STATUS_FAILED",

"set module status failed."));

}

CIMDisableModuleResponseMessage * response =

new CIMDisableModuleResponseMessage(

dynamic_cast<CIMDisableModuleResponseMessage*>(

request->messageId,

request->buildResponse());

CIMException(),

request->queueIds.copyAndPop(),

operationalStatus);

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 ());

PEG_METHOD_EXIT();

return(response);

}

Message * DefaultProviderManager::handleEnableModuleRequest(const Message * message) throw()

Message * DefaultProviderManager::handleEnableModuleRequest(const Message * message)

{

// HACK

ProviderRegistrationManager * _providerRegistrationManager = ProviderManager::getProviderRegistrationManager();

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleEnableModuleRequest");

CIMEnableModuleRequestMessage * request =

Line 2463

Line 2008

PEGASUS_ASSERT(request != 0);

// get module status

CIMInstance mInstance = request->providerModule;

Array<Uint16> operationalStatus;

Uint32 pos = mInstance.findProperty(CIMName ("OperationalStatus"));

operationalStatus.append(CIM_MSE_OPSTATUS_VALUE_OK);

if(pos != PEG_NOT_FOUND)

CIMEnableModuleResponseMessage* response =

{

dynamic_cast<CIMEnableModuleResponseMessage*>(

request->buildResponse());

// ATTN-CAKG-P2-20020821: Check for null status?

PEGASUS_ASSERT(response != 0);

mInstance.getProperty(pos).getValue().get(operationalStatus);

response->operationalStatus = operationalStatus;

PEG_METHOD_EXIT();

return(response);

}

// update module status from Stopped to OK

Message * DefaultProviderManager::handleStopAllProvidersRequest(const Message * message)

for(Uint32 i=0, n = operationalStatus.size(); i < n; i++)

{

if(operationalStatus[i] == _MODULE_STOPPED)

{

operationalStatus.remove(i);

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleStopAllProvidersRequest");

}

operationalStatus.append(_MODULE_OK);

CIMStopAllProvidersRequestMessage * request =

dynamic_cast<CIMStopAllProvidersRequestMessage *>(const_cast<Message *>(message));

PEGASUS_ASSERT(request != 0);

// get module name

String moduleName;

Uint32 pos2 = mInstance.findProperty(CIMName ("Name"));

CIMStopAllProvidersResponseMessage* response =

dynamic_cast<CIMStopAllProvidersResponseMessage*>(

request->buildResponse());

PEGASUS_ASSERT(response != 0);

// tell the provider manager to shutdown all the providers

providerManager.shutdownAllProviders();

if(pos2 != PEG_NOT_FOUND)

try

{

mInstance.getProperty(pos2).getValue().get(moduleName);

// Delete the response handlers that were not explicitly disabled.

}

AutoMutex lock(_responseTableMutex);

if(_providerRegistrationManager->setProviderModuleStatus

for (IndicationResponseTable::Iterator i = _responseTable.start();

(moduleName, operationalStatus) == false)

i != 0; i++)

{

//l10n

EnableIndicationsResponseHandler *handler = i.value();

//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, "set module status failed.");

delete handler;

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, MessageLoaderParms(

"ProviderManager.DefaultProviderManager.SET_MODULE_STATUS_FAILED",

"set module status failed."));

}

CIMEnableModuleResponseMessage * response =

_responseTable.clear();

new CIMEnableModuleResponseMessage(

}

request->messageId,

catch (...) { }

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);

}

Message * DefaultProviderManager::handleStopAllProvidersRequest(const Message * message) throw()

Message *

DefaultProviderManager::handleSubscriptionInitCompleteRequest

(const Message * message)

{

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleStopAllProvidersRequest");

PEG_METHOD_ENTER (TRC_PROVIDERMANAGER,

"DefaultProviderManager::handleSubscriptionInitCompleteRequest");

CIMStopAllProvidersRequestMessage * request =

CIMSubscriptionInitCompleteRequestMessage * request =

dynamic_cast<CIMStopAllProvidersRequestMessage *>(const_cast<Message *>(message));

dynamic_cast <CIMSubscriptionInitCompleteRequestMessage *>

(const_cast <Message *> (message));

PEGASUS_ASSERT(request != 0);

CIMStopAllProvidersResponseMessage * response =

CIMSubscriptionInitCompleteResponseMessage * response =

new CIMStopAllProvidersResponseMessage(

dynamic_cast <CIMSubscriptionInitCompleteResponseMessage *>

request->messageId,

(request->buildResponse ());

CIMException(),

request->queueIds.copyAndPop());

PEGASUS_ASSERT(response != 0);

// preserve message key

response->setKey(request->getKey());

// Set indicator

_subscriptionInitComplete = true;

// Set HTTP method in response from request

response->setHttpMethod (request->getHttpMethod ());

// For each provider that has at least one subscription, call

// provider's enableIndications method

Array <Provider *> enableProviders;

enableProviders = providerManager.getIndicationProvidersToEnable ();

// tell the provider manager to shutdown all the providers

Uint32 numProviders = enableProviders.size ();

providerManager.shutdownAllProviders();

for (Uint32 i = 0; i < numProviders; i++)

{

try

{

CIMInstance provider;

provider = enableProviders [i]->getProviderInstance ();

PEG_METHOD_EXIT();

// Get cached or load new provider module

OpProviderHolder ph = providerManager.getProvider(

enableProviders[i]->getModule()->getFileName(),

enableProviders[i]->getName());

_callEnableIndications (provider, _indicationCallback, ph);

}

catch (CIMException & e)

{

PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,

"CIMException: " + e.getMessage ());

}

catch (Exception & e)

{

PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,

"Exception: " + e.getMessage ());

}

catch(...)

{

PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,

"Unknown error in handleSubscriptionInitCompleteRequest");

}

PEG_METHOD_EXIT ();

return(response);

}

void DefaultProviderManager::_insertEntry (

const Provider & provider,

const EnableIndicationsResponseHandler *handler)

EnableIndicationsResponseHandler* handler)

{

PEG_METHOD_ENTER (TRC_INDICATION_SERVICE,

PEG_METHOD_ENTER (TRC_PROVIDERMANAGER,

"DefaultProviderManager::_insertEntry");

String tableKey = _generateKey

String tableKey = _generateKey(provider);

(provider);

_responseTable.insert (tableKey, const_cast<EnableIndicationsResponseHandler *>(handler));

AutoMutex lock(_responseTableMutex);

_responseTable.insert(tableKey, handler);

PEG_METHOD_EXIT();

}

Line 2580

Line 2147

EnableIndicationsResponseHandler * DefaultProviderManager::_removeEntry(

const String & key)

{

PEG_METHOD_ENTER (TRC_INDICATION_SERVICE,

PEG_METHOD_ENTER (TRC_PROVIDERMANAGER,

"DefaultProviderManager::_removeEntry");

EnableIndicationsResponseHandler *ret = 0;

AutoMutex lock(_responseTableMutex);

_responseTable.lookup(key, ret);

_responseTable.remove(key);

PEG_METHOD_EXIT();

Line 2596

Line 2165

{

String tableKey;

PEG_METHOD_ENTER (TRC_INDICATION_SERVICE,

PEG_METHOD_ENTER (TRC_PROVIDERMANAGER,

"DefaultProviderManager::_generateKey");

Line 2612

Line 2181

return(tableKey);

}

String DefaultProviderManager::_generateKey (

const String & providerName,

const String & providerFileName)

{

String tableKey;

PEG_METHOD_ENTER (TRC_PROVIDERMANAGER,

"DefaultProviderManagerService::_generateKey");

// Append providerName and providerFileName to key

tableKey.append (providerName);

tableKey.append (providerFileName);

PEG_METHOD_EXIT ();

return tableKey;

}

ProviderName DefaultProviderManager::_resolveProviderName(

const ProviderIdContainer & providerId)

{

String providerName;

String fileName;

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 ProviderName(providerName, fileName, interfaceName, 0);

}

Boolean DefaultProviderManager::hasActiveProviders()

{

return providerManager.hasActiveProviders();

}

void DefaultProviderManager::unloadIdleProviders()

{

providerManager.unloadIdleProviders();

}

void DefaultProviderManager::_callEnableIndications

(CIMInstance & req_provider,

PEGASUS_INDICATION_CALLBACK_T _indicationCallback,

OpProviderHolder & ph)

{

PEG_METHOD_ENTER (TRC_PROVIDERMANAGER,

"DefaultProviderManager::_callEnableIndications");

try

{

CIMRequestMessage * request = 0;

CIMResponseMessage * response = 0;

EnableIndicationsResponseHandler * enableHandler =

new EnableIndicationsResponseHandler(

request,

response,

req_provider,

_indicationCallback,

_responseChunkCallback);

PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"Calling provider.enableIndications: " +

ph.GetProvider ().getName ());

pm_service_op_lock op_lock (& ph.GetProvider ());

ph.GetProvider ().protect ();

ph.GetProvider ().enableIndications (* enableHandler);

// Store the handler so it is persistent for as

// long as the provider has indications enabled

PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"Storing indication handler for " +

ph.GetProvider ().getName ());

_insertEntry (ph.GetProvider (), enableHandler);

}

catch (CIMException & e)

{

PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,

"CIMException: " + e.getMessage ());

Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::WARNING,

"ProviderManager.Default.DefaultProviderManager."

"ENABLE_INDICATIONS_FAILED",

"Failed to enable indications for provider $0: $1.",

ph.GetProvider ().getName (), e.getMessage ());

}

catch (Exception & e)

{

PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,

"Exception: " + e.getMessage ());

Logger::put_l (Logger::ERROR_LOG, System::CIMSERVER, Logger::WARNING,

"ProviderManager.Default.DefaultProviderManager."

"ENABLE_INDICATIONS_FAILED",

"Failed to enable indications for provider $0: $1.",

ph.GetProvider ().getName (), e.getMessage ());

}

catch(...)

{

PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,

"Unexpected error in _callEnableIndications");

Logger::put_l (Logger::ERROR_LOG, System::CIMSERVER, Logger::WARNING,

"ProviderManager.Default.DefaultProviderManager."

"ENABLE_INDICATIONS_FAILED_UNKNOWN",

"Failed to enable indications for provider $0.",

ph.GetProvider ().getName ());

}

PEG_METHOD_EXIT ();

}

PEGASUS_NAMESPACE_END

Legend:

Removed from v.1.1
changed lines
	Added in v.1.61.2.3

No CVS admin address has been configured