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.10.2.1 and 1.68

version 1.10.2.1, 2004/02/17 01:35:03

version 1.68, 2006/08/23 19:54:31

Line 1

//%2003////////////////////////////////////////////////////////////////////////

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

// Company, L. P., IBM Corp., 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 23

Line 29

//==============================================================================

// Author: Chip Vincent (cvincent@us.ibm.com)

// Modified By: Carol Ann Krug Graves, Hewlett-Packard Company

// (carolann_graves@hp.com)

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

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

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

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

#include "DefaultProviderManager.h"

#include <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/AutoPThreadSecurity.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."); \

}

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

#include <Pegasus/ProviderManager2/ProviderManagerService.h>

PEGASUS_NAMESPACE_BEGIN

Line 74

Line 92

};

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

static LocalProviderManager providerManager;

DefaultProviderManager::DefaultProviderManager(void)

{

_subscriptionInitComplete = false;

}

DefaultProviderManager::~DefaultProviderManager(void)

{

}

Message * DefaultProviderManager::processMessage(Message * request) throw()

Message * DefaultProviderManager::processMessage(Message * request)

{

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,

"DefaultProviderManager::processMessage()");

Line 126

Line 138

break;

case CIM_EXEC_QUERY_REQUEST_MESSAGE:

response = handleExecuteQueryRequest(request);

response = handleExecQueryRequest(request);

break;

case CIM_ASSOCIATORS_REQUEST_MESSAGE:

Line 169

Line 181

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 193

Line 197

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 204

Line 216

return(response);

}

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

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

{

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

Line 214

Line 226

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

AutoPThreadSecurity threadLevelSecurity(request->operationContext);

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

Line 295

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 256

Line 318

request->instanceName.getClassName(),

request->instanceName.getKeyBindings());

ProviderName name(

objectPath.toString(),

String::EMPTY,

0);

// resolve provider name

name = _resolveProviderName(name);

ProviderName name = _resolveProviderName(

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

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

Line 340

"Calling provider.getInstance: " +

ph.GetProvider().getName());

AutoPThreadSecurity threadLevelSecurity(context);

pm_service_op_lock op_lock(&ph.GetProvider());

STAT_GETSTARTTIME;

StatProviderTimeMeasurement providerTime(response);

ph.GetProvider().getInstance(

context,

Line 296

Line 354

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

return(response);

}

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

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

{

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

Line 335

Line 371

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 366

Line 395

request->nameSpace,

request->className);

ProviderName name(

objectPath.toString(),

String::EMPTY,

0);

// resolve provider name

name = _resolveProviderName(name);

ProviderName name = _resolveProviderName(

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

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

Line 417

"Calling provider.enumerateInstances: " +

ph.GetProvider().getName());

AutoPThreadSecurity threadLevelSecurity(context);

pm_service_op_lock op_lock(&ph.GetProvider());

STAT_GETSTARTTIME;

StatProviderTimeMeasurement providerTime(response);

ph.GetProvider().enumerateInstances(

context,

Line 406

Line 431

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

return(response);

}

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

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

{

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

Line 445

Line 449

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 477

Line 474

request->nameSpace,

request->className);

// build an internal provider name from the request arguments

ProviderName name(

objectPath.toString(),

String::EMPTY,

0);

// resolve provider name

name = _resolveProviderName(name);

ProviderName name = _resolveProviderName(

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

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

"Calling provider.enumerateInstanceNames: " +

ph.GetProvider().getName());

AutoPThreadSecurity threadLevelSecurity(context);

pm_service_op_lock op_lock(&ph.GetProvider());

STAT_GETSTARTTIME;

StatProviderTimeMeasurement providerTime(response);

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

return(response);

}

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

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

{

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

Line 553

Line 524

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

Line 549

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

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

ProviderName name(

objectPath.toString(),

String::EMPTY,

0);

// resolve provider name

name = _resolveProviderName(name);

ProviderName name = _resolveProviderName(

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

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

"Calling provider.createInstance: " +

ph.GetProvider().getName());

AutoPThreadSecurity threadLevelSecurity(context);

pm_service_op_lock op_lock(&ph.GetProvider());

STAT_GETSTARTTIME;

StatProviderTimeMeasurement providerTime(response);

ph.GetProvider().createInstance(

context,

Line 621

Line 581

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

return(response);

}

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

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

{

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

Line 661

Line 600

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

Line 625

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

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

ProviderName name(

objectPath.toString(),

String::EMPTY,

0);

// resolve provider name

name = _resolveProviderName(name);

ProviderName name = _resolveProviderName(

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

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

Line 647

"Calling provider.modifyInstance: " +

ph.GetProvider().getName());

AutoPThreadSecurity threadLevelSecurity(context);

pm_service_op_lock op_lock(&ph.GetProvider());

STAT_GETSTARTTIME;

StatProviderTimeMeasurement providerTime(response);

ph.GetProvider().modifyInstance(

context,

Line 732

Line 661

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

return(response);

}

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

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

{

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

Line 772

Line 680

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

Line 705

request->instanceName.getClassName(),

request->instanceName.getKeyBindings());

ProviderName name(

objectPath.toString(),

String::EMPTY,

0);

// resolve provider name

name = _resolveProviderName(name);

ProviderName name = _resolveProviderName(

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

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

"Calling provider.deleteInstance: " +

ph.GetProvider().getName());

AutoPThreadSecurity threadLevelSecurity(context);

pm_service_op_lock op_lock(&ph.GetProvider());

STAT_GETSTARTTIME;

StatProviderTimeMeasurement providerTime(response);

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

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

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

// Set HTTP method in response from request

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

// l10n

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

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

PEG_METHOD_EXIT();

return(response);

}

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

{

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

CIMAssociatorsRequestMessage * request =

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

PEGASUS_ASSERT(request != 0);

CIMAssociatorsResponseMessage * response =

new CIMAssociatorsResponseMessage(

request->messageId,

CIMException(),

request->queueIds.copyAndPop(),

Array<CIMObject>());

PEGASUS_ASSERT(response != 0);

// preserve message key

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

// create a handler for this request

AssociatorsResponseHandler handler(request, response);

ExecQueryResponseHandler 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::handleExecQueryRequest - "

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

System::getHostName(),

request->nameSpace.getString(),

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

request->className.getString()));

// make target object path

CIMObjectPath objectPath(

System::getHostName(),

request->nameSpace,

request->objectName.getClassName());

request->className);

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

ProviderName name(

objectPath.toString(),

String::EMPTY,

0);

// resolve provider name

name = _resolveProviderName(name);

ProviderName name = _resolveProviderName(

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

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

// ATTN KS STAT_GETSTARTTIME;

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

pm_service_op_lock op_lock(&ph.GetProvider());

ph.GetProvider().associators(

// forward request

context,

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

objectPath,

"Calling provider.executeQueryRequest: " +

request->assocClass,

ph.GetProvider().getName());

request->resultClass,

request->role,

AutoPThreadSecurity threadLevelSecurity(context);

request->resultRole,

request->includeQualifiers,

pm_service_op_lock op_lock(&ph.GetProvider());

request->includeClassOrigin,

request->propertyList.getPropertyNameArray(),

StatProviderTimeMeasurement providerTime(response);

ph.GetProvider().execQuery(

context,

objectPath,

qx,

handler);

STAT_PMS_PROVIDEREND;

}

catch(CIMException & e)

HandleCatch(handler);

{

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

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

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

PEG_METHOD_EXIT();

return(response);

}

catch(Exception & e)

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

{

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

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

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

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

CIMAssociatorsRequestMessage * request =

}

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

catch(...)

PEGASUS_ASSERT(request != 0);

CIMAssociatorsResponseMessage* response =

dynamic_cast<CIMAssociatorsResponseMessage*>(

request->buildResponse());

PEGASUS_ASSERT(response != 0);

// create a handler for this request

AssociatorsResponseHandler handler(

request, response, _responseChunkCallback);

// process the request

try

{

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

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

"Exception: Unknown");

Logger::TRACE,

"DefaultProviderManager::handleAssociatorsRequest - "

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

System::getHostName(),

request->nameSpace.getString(),

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

// make target object path

CIMObjectPath objectPath(

System::getHostName(),

request->nameSpace,

request->objectName.getClassName());

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

CIMObjectPath assocPath(

System::getHostName(),

request->nameSpace,

request->assocClass.getString());

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

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

AutoPThreadSecurity threadLevelSecurity(context);

StatProviderTimeMeasurement providerTime(response);

pm_service_op_lock op_lock(&ph.GetProvider());

ph.GetProvider().associators(

context,

objectPath,

request->assocClass,

request->resultClass,

request->role,

request->resultRole,

request->includeQualifiers,

request->includeClassOrigin,

request->propertyList,

handler);

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

}

HandleCatch(handler);

PEG_METHOD_EXIT();

return(response);

}

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

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

{

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

Line 1019

Line 913

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 1053

Line 940

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

ProviderName name(

CIMObjectPath assocPath(

objectPath.toString(),

System::getHostName(),

String::EMPTY,

request->nameSpace,

String::EMPTY,

request->assocClass.getString());

String::EMPTY,

0);

// resolve provider name

name = _resolveProviderName(name);

ProviderName name = _resolveProviderName(

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

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

AutoPThreadSecurity threadLevelSecurity(context);

StatProviderTimeMeasurement providerTime(response);

pm_service_op_lock op_lock(&ph.GetProvider());

Line 1085

Line 975

request->resultRole,

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

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

{

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

Line 1124

Line 993

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 1158

Line 1020

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

ProviderName name(

CIMObjectPath resultPath(

objectPath.toString(),

System::getHostName(),

String::EMPTY,

request->nameSpace,

String::EMPTY,

request->resultClass.getString());

String::EMPTY,

0);

// resolve provider name

name = _resolveProviderName(name);

ProviderName name = _resolveProviderName(

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

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

STAT_GETSTARTTIME;

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"Calling provider.references: " +

ph.GetProvider().getName());

AutoPThreadSecurity threadLevelSecurity(context);

StatProviderTimeMeasurement providerTime(response);

pm_service_op_lock op_lock(&ph.GetProvider());

ph.GetProvider().references(

Line 1194

Line 1057

request->role,

request->includeQualifiers,

request->includeClassOrigin,

request->propertyList.getPropertyNameArray(),

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

return(response);

}

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

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

{

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

Line 1236

Line 1078

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 1268

Line 1105

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

ProviderName name(

CIMObjectPath resultPath(

objectPath.toString(),

System::getHostName(),

String::EMPTY,

request->nameSpace,

String::EMPTY,

request->resultClass.getString());

String::EMPTY,

0);

// resolve provider name

name = _resolveProviderName(name);

ProviderName name = _resolveProviderName(

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

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

STAT_GETSTARTTIME;

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"Calling provider.referenceNames: " +

ph.GetProvider().getName());

AutoPThreadSecurity threadLevelSecurity(context);

StatProviderTimeMeasurement providerTime(response);

pm_service_op_lock op_lock(&ph.GetProvider());

ph.GetProvider().referenceNames(

Line 1304

Line 1142

request->role,

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

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

{

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

Line 1344

Line 1161

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

Line 1185

request->instanceName.getClassName(),

request->instanceName.getKeyBindings());

ProviderName name(

objectPath.toString(),

String::EMPTY,

0);

// resolve provider name

name = _resolveProviderName(name);

ProviderName name = _resolveProviderName(

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

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

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"Calling provider.getProperty: " +

ph.GetProvider().getName());

AutoPThreadSecurity threadLevelSecurity(context);

StatProviderTimeMeasurement providerTime(response);

// forward request

pm_service_op_lock op_lock(&ph.GetProvider());

Line 1413

Line 1219

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

return(response);

}

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

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

{

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

Line 1452

Line 1237

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 1486

Line 1262

request->instanceName.getClassName(),

request->instanceName.getKeyBindings());

ProviderName name(

objectPath.toString(),

String::EMPTY,

0);

// resolve provider name

name = _resolveProviderName(name);

ProviderName name = _resolveProviderName(

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

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

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"Calling provider.setProperty: " +

ph.GetProvider().getName());

AutoPThreadSecurity threadLevelSecurity(context);

StatProviderTimeMeasurement providerTime(response);

// forward request

pm_service_op_lock op_lock(&ph.GetProvider());

Line 1526

Line 1298

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

return(response);

}

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

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

{

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

Line 1566

Line 1317

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

Line 1342

request->instanceName.getClassName(),

request->instanceName.getKeyBindings());

ProviderName name(

objectPath.toString(),

String::EMPTY,

0);

// resolve provider name

name = _resolveProviderName(name);

ProviderName name = _resolveProviderName(

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

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

CIMObjectPath instanceReference(request->instanceName);

// ATTN: propagate namespace

instanceReference.setNameSpace(request->nameSpace);

// forward request

STAT_GETSTARTTIME;

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"Calling provider.invokeMethod: " +

ph.GetProvider().getName());

AutoPThreadSecurity threadLevelSecurity(context);

StatProviderTimeMeasurement providerTime(response);

pm_service_op_lock op_lock(&ph.GetProvider());

ph.GetProvider().invokeMethod(

Line 1642

Line 1379

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 1681

Line 1397

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

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

OperationResponseHandler handler(request, response);

try

{

Line 1710

Line 1418

}

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

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

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

Logger::TRACE,

"DefaultProviderManager::handleCreateSubscriptionRequest - "

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

System::getHostName(),

request->nameSpace.getString(),

temp);

temp));

// NOTE: the provider and provider module name are embedded in the request, presumably to reduce

CIMInstance req_provider, req_providerModule;

// the number of provider lookups (but this should be trivial if the data is cached and accessed

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

// from the same source). to keep the lookups consistent, use the first class name, combined

req_provider = pidc.getProvider();

// with the other information in the request, and create an object path that can be used to

req_providerModule = pidc.getModule();

// resolve the provider using the ProviderRegistrar.

// make target object path

String physicalName=_resolvePhysicalName( req_providerModule.getProperty(

CIMObjectPath objectPath(

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

System::getHostName(),

request->nameSpace,

request->classNames[0].getString());

ProviderName name(

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

objectPath.toString(),

physicalName,

String::EMPTY,

req_providerModule.getProperty(req_providerModule.findProperty

String::EMPTY,

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

String::EMPTY,

0);

// resolve provider name

name = _resolveProviderName(name);

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

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

Line 1481

"Calling provider.createSubscription: " +

ph.GetProvider().getName());

AutoPThreadSecurity threadLevelSecurity(context);

pm_service_op_lock op_lock(&ph.GetProvider());

ph.GetProvider().createSubscription(

Line 1785

Line 1491

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)

{

Line 1813

Line 1536

return(response);

}

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

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

{

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

Line 1823

Line 1546

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

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

OperationResponseHandler handler(request, response);

try

{

Line 1852

Line 1567

}

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

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

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

Logger::TRACE,

"DefaultProviderManager::handleCreateSubscriptionRequest - "

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

System::getHostName(),

request->nameSpace.getString(),

temp);

temp));

// NOTE: the provider and provider module name are embedded in the request, presumably to reduce

CIMInstance req_provider, req_providerModule;

// the number of provider lookups (but this should be trivial if the data is cached and accessed

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

// from the same source). to keep the lookups consistent, use the first class name, combined

req_provider = pidc.getProvider();

// with the other information in the request, and create an object path that can be used to

req_providerModule = pidc.getModule();

// resolve the provider using the ProviderRegistrar.

// make target object path

String physicalName=_resolvePhysicalName( req_providerModule.getProperty(

CIMObjectPath objectPath(

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

System::getHostName(),

request->nameSpace,

request->classNames[0].getString());

ProviderName name(

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

objectPath.toString(),

physicalName,

String::EMPTY,

req_providerModule.getProperty(req_providerModule.findProperty

String::EMPTY,

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

String::EMPTY,

0);

// resolve provider name

name = _resolveProviderName(name);

// 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(request->operationContext.get(IdentityContainer::NAME));

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

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

context.insert(SubscriptionInstanceContainer

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

(request->subscriptionInstance));

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

context.insert(SubscriptionFilterConditionContainer

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

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

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

context.insert(SubscriptionLanguageListContainer

(request->acceptLanguages));

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

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

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

Line 1919

Line 1624

"Calling provider.modifySubscription: " +

ph.GetProvider().getName());

AutoPThreadSecurity threadLevelSecurity(context);

pm_service_op_lock op_lock(&ph.GetProvider());

ph.GetProvider().modifySubscription(

Line 1927

Line 1634

classNames,

propertyList,

repeatNotificationPolicy);

}

catch(CIMException & e)

{

Line 1955

Line 1663

return(response);

}

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

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

{

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

Line 1965

Line 1673

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

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

OperationResponseHandler handler(request, response);

try

{

Line 1994

Line 1694

}

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

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

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

Logger::TRACE,

"DefaultProviderManager::handleDeleteSubscriptionRequest - "

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

System::getHostName(),

request->nameSpace.getString(),

temp);

temp));

// NOTE: the provider and provider module name are embedded in the request, presumably to reduce

CIMInstance req_provider, req_providerModule;

// the number of provider lookups (but this should be trivial if the data is cached and accessed

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

// from the same source). to keep the lookups consistent, use the first class name, combined

// with the other information in the request, and create an object path that can be used to

// resolve the provider using the ProviderRegistrar.

// make target object path

req_provider = pidc.getProvider();

CIMObjectPath objectPath(

req_providerModule = pidc.getModule();

System::getHostName(),

request->nameSpace,

request->classNames[0].getString());

ProviderName name(

String physicalName=_resolvePhysicalName( req_providerModule.getProperty(

objectPath.toString(),

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

String::EMPTY,

0);

// resolve provider name

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

name = _resolveProviderName(name);

physicalName,

req_providerModule.getProperty(req_providerModule.findProperty

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

0);

// 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(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 2055

Line 1747

"Calling provider.deleteSubscription: " +

ph.GetProvider().getName());

AutoPThreadSecurity threadLevelSecurity(context);

pm_service_op_lock op_lock(&ph.GetProvider());

ph.GetProvider().deleteSubscription(

context,

subscriptionName,

classNames);

}

catch(CIMException & e)

{

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

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

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

}

catch(Exception & e)

{

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

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

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

}

catch(...)

{

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"Exception: Unknown");

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

}

PEG_METHOD_EXIT();

return(response);

}

Message * DefaultProviderManager::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(

// Decrement count of current subscriptions for this provider

request->messageId,

CIMException(),

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

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

EnableIndicationsResponseHandler *handler =

new EnableIndicationsResponseHandler(request, response,

request->provider, ProviderManagerService::providerManagerService);

try

{

String physicalName=_resolvePhysicalName(

request->providerModule.getProperty(

request->providerModule.findProperty("Location")).getValue().toString());

ProviderName name(String::EMPTY,

request->provider.getProperty(request->providerModule.findProperty

("Name")).getValue ().toString (),

physicalName,

request->providerModule.getProperty(request->providerModule.findProperty

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

0);

// get cached or load new provider module

OpProviderHolder ph =

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

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"Calling provider.enableIndications: " +

ph.GetProvider().getName());

pm_service_op_lock op_lock(&ph.GetProvider());

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

response->cimException = CIMException(CIM_ERR_FAILED, MessageLoaderParms(

"ProviderManager.DefaultProviderManager.INTERNAL_ERROR",

"Internal Error"));

}

catch(...)

{

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"Exception: Unknown");

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

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

CIMDisableIndicationsRequestMessage * request =

// the last subscription has been deleted

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

// Call the provider's disableIndications method

PEGASUS_ASSERT(request != 0);

if (_subscriptionInitComplete)

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

{

String physicalName=_resolvePhysicalName(

request->providerModule.getProperty(

request->providerModule.findProperty("Location")).getValue().toString());

ProviderName name(String::EMPTY,

request->provider.getProperty(request->providerModule.findProperty

("Name")).getValue ().toString (),

physicalName,

request->providerModule.getProperty(request->providerModule.findProperty

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

0);

// get cached or load new provider module

OpProviderHolder ph =

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

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"Calling provider.disableIndications: " +

ph.GetProvider().getName());

Line 2238

Line 1776

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

response->cimException = CIMException(CIM_ERR_FAILED, MessageLoaderParms(

"ProviderManager.DefaultProviderManager.INTERNAL_ERROR",

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

"Internal Error"));

}

catch(...)

{

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"Exception: Unknown");

response->cimException = CIMException(CIM_ERR_FAILED, MessageLoaderParms(

"ProviderManager.DefaultProviderManager.UNKNOWN_ERROR",

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

"Unknown Error"));

}

PEG_METHOD_EXIT();

Line 2274

Line 1814

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

{

ProviderName name(

String::EMPTY,

0);

ProviderName name(

String::EMPTY,

objectPath.toString());

// resolve provider name

name = _resolveProviderName(name);

ProviderName name = _resolveProviderName(

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

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

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"Calling provider.: " +

Line 2328

Line 1847

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

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

CIMInstance indication_copy = request->indicationInstance;

SimpleIndicationResponseHandler handler;

StatProviderTimeMeasurement providerTime(response);

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 2386

Line 1888

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

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

CIMDisableModuleRequestMessage * request =

Line 2398

Line 1897

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;

if(!disableProviderOnly)

String physicalName=_resolvePhysicalName(

mInstance.getProperty(

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

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

{

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

String pName(_pInstances[i].getProperty(

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

Sint16 ret_value = providerManager.disableProvider(pName);

if(pos2 != PEG_NOT_FOUND)

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

{

if (_indicationProviders[i])

{

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

// Reset the indication provider's count of current

// subscriptions since it has been disabled

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

if (physicalName.size () > 0)

{

OpProviderHolder ph = providerManager.getProvider(

physicalName, pName);

ph.GetProvider ().resetSubscriptions ();

}

// update module status from OK to Stopping

// If it is an indication provider

// remove the entry from the table since the

// provider has been disabled

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

delete _removeEntry(_generateKey(pName,physicalName));

{

}

if(operationalStatus[i] == _MODULE_OK)

}

else

{

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;

String physicalName=_resolvePhysicalName(request->providerModule.getProperty(

request->providerModule.findProperty("Location")).getValue().toString());

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

{

providerManager.unloadProvider(_pInstances[i].getProperty(

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

request->providerModule.findProperty

"Exception: Unknown");

("Name")).getValue ().toString (),

//l10n

physicalName);

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

cimException = PEGASUS_CIM_EXCEPTION_L(

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

}

else

operationalStatus.append(_MODULE_STOPPED);

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

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

CIMEnableModuleRequestMessage * request =

Line 2522

Line 2031

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

CIMStopAllProvidersResponseMessage* response =

String moduleName;

dynamic_cast<CIMStopAllProvidersResponseMessage*>(

request->buildResponse());

PEGASUS_ASSERT(response != 0);

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

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

Line 2170

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 2655

Line 2188

{

String tableKey;

PEG_METHOD_ENTER (TRC_INDICATION_SERVICE,

PEG_METHOD_ENTER (TRC_PROVIDERMANAGER,

"DefaultProviderManager::_generateKey");

Line 2671

Line 2204

return(tableKey);

}

String DefaultProviderManager::_resolvePhysicalName(const String & name)

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

{

String physicalName;

CIMRequestMessage * request = 0;

CIMResponseMessage * response = 0;

EnableIndicationsResponseHandler * enableHandler =

new EnableIndicationsResponseHandler(

request,

response,

req_provider,

_indicationCallback,

_responseChunkCallback);

#if defined(PEGASUS_PLATFORM_WIN32_IX86_MSVC)

PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL4,

physicalName = name + String(".dll");

"Calling provider.enableIndications: " +

#elif defined(PEGASUS_PLATFORM_LINUX_IX86_GNU) || defined(PEGASUS_PLATFORM_LINUX_IA86_GNU)

ph.GetProvider ().getName ());

String root = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir"));

physicalName = root + String("/lib") + name + String(".so");

#elif defined(PEGASUS_OS_HPUX)

String root = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir"));

physicalName = root + String("/lib") + name + String(".sl");

#elif defined(PEGASUS_OS_OS400)

physicalName = name;

#else

String root = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir"));

physicalName = root + String("/lib") + name + String(".so");

#endif

return physicalName;

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

ProviderName DefaultProviderManager::_resolveProviderName(const ProviderName & providerName)

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

{

ProviderName temp = findProvider(providerName);

PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,

"Unexpected error in _callEnableIndications");

String physicalName = _resolvePhysicalName(temp.getPhysicalName());

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

}

temp.setPhysicalName(physicalName);

PEG_METHOD_EXIT ();

}

return(temp);

ProviderManager* DefaultProviderManager::createDefaultProviderManagerCallback()

{

return new DefaultProviderManager();

}

PEGASUS_NAMESPACE_END

Legend:

Removed from v.1.10.2.1
changed lines
	Added in v.1.68

No CVS admin address has been configured