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.12 and 1.54

version 1.12, 2004/01/27 13:48:11

version 1.54, 2005/07/27 20:51:14

Line 1

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

//%2005////////////////////////////////////////////////////////////////////////

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

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

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

Line 30

Line 34

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

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

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

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

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

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

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

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

Line 37

Line 45

#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/Common/QueryExpression.h>

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

#include <Pegasus/ProviderManager2/QueryExpressionFactory.h>

#include <Pegasus/Config/ConfigManager.h>

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

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

#include <Pegasus/ProviderManager2/OperationResponseHandler.h>

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

#include <Pegasus/ProviderManager2/ProviderManagerService.h>

#include <Pegasus/ProviderManager2/ProviderType.h>

PEGASUS_NAMESPACE_BEGIN

Line 76

Line 83

};

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

Line 172

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 195

Line 188

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 206

Line 207

return(response);

}

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

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

{

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

Line 216

Line 217

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

try

{

// resolve provider name

ProviderName name = _resolveProviderName(

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

// get cached or load new provider module

OpProviderHolder ph = providerManager.getProvider(

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

}

catch(CIMException & e)

{

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL3,

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

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

}

catch(Exception & e)

{

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL3,

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

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

}

catch(...)

{

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL3,

"Exception: Unknown");

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

}

PEG_METHOD_EXIT();

return(response);

}

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

{

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

Line 226

Line 283

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

Line 258

Line 305

request->instanceName.getClassName(),

request->instanceName.getKeyBindings());

ProviderName name(

objectPath.toString(),

String::EMPTY,

ProviderType::INSTANCE);

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

Line 365

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

return(response);

}

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

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

{

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

Line 337

Line 380

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

Line 368

Line 401

request->nameSpace,

request->className);

ProviderName name(

objectPath.toString(),

String::EMPTY,

ProviderType::INSTANCE);

// resolve provider name

name = _resolveProviderName(name);

ProviderName name = _resolveProviderName(

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

// get cached or load new provider module

OpProviderHolder ph = providerManager.getProvider(name.getPhysicalName(),

OpProviderHolder ph = providerManager.getProvider(

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 434

Line 461

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

return(response);

}

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

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

{

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

Line 447

Line 476

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

Line 479

Line 498

request->nameSpace,

request->className);

// build an internal provider name from the request arguments

ProviderName name(

objectPath.toString(),

String::EMPTY,

ProviderType::INSTANCE);

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

Line 541

Line 553

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

return(response);

}

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

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

{

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

Line 555

Line 569

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

Line 587

Line 591

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

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

ProviderName name(

objectPath.toString(),

String::EMPTY,

ProviderType::INSTANCE);

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

Line 649

Line 647

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

return(response);

}

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

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

{

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

Line 663

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

Line 694

Line 685

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

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

ProviderName name(

objectPath.toString(),

String::EMPTY,

ProviderType::INSTANCE);

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

Line 745

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

return(response);

}

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

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

{

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

Line 774

Line 761

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

Line 805

Line 783

request->instanceName.getClassName(),

request->instanceName.getKeyBindings());

ProviderName name(

objectPath.toString(),

String::EMPTY,

ProviderType::INSTANCE);

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

Line 866

Line 838

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

return(response);

}

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

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

{

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

Line 879

Line 853

PEGASUS_ASSERT(request != 0);

CIMExecQueryResponseMessage * response =

new CIMExecQueryResponseMessage(

dynamic_cast<CIMExecQueryResponseMessage*>(

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

ExecQueryResponseHandler handler(request, response);

Line 910

Line 874

request->nameSpace,

request->className);

ProviderName name(

objectPath.toString(),

String::EMPTY,

ProviderType::QUERY);

// 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.getPhysicalName(), name.getLogicalName());

name.getLogicalName(), String::EMPTY);

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

String errorString = " instance provider is registered supporting execQuery "

Line 935

Line 892

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

QueryExpression qx(QueryExpressionFactory::routeBuildQueryExpressionRep

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

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

// forward request

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

Line 968

Line 924

}

catch(Exception & e)

{

cout<<"--- exception not a CIMInstanceQueryProvider"<<endl;

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

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

Line 987

Line 942

return(response);

}

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

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

{

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

Line 997

Line 952

PEGASUS_ASSERT(request != 0);

CIMAssociatorsResponseMessage * response =

new CIMAssociatorsResponseMessage(

dynamic_cast<CIMAssociatorsResponseMessage*>(

request->messageId,

request->buildResponse());

CIMException(),

request->queueIds.copyAndPop(),

Array<CIMObject>());

PEGASUS_ASSERT(response != 0);

// preserve message key

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

// create a handler for this request

AssociatorsResponseHandler handler(request, response);

Line 1028

Line 976

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

ProviderName name(

CIMObjectPath assocPath(

objectPath.toString(),

System::getHostName(),

String::EMPTY,

request->nameSpace,

String::EMPTY,

request->assocClass.getString());

String::EMPTY,

ProviderType::ASSOCIATION);

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

STAT_GETSTARTTIME;

pm_service_op_lock op_lock(&ph.GetProvider());

ph.GetProvider().associators(

Line 1061

Line 1008

request->resultRole,

request->includeQualifiers,

request->includeClassOrigin,

request->propertyList.getPropertyNameArray(),

request->propertyList,

handler);

STAT_PMS_PROVIDEREND;

Line 1090

Line 1037

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

return(response);

}

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

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

{

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

Line 1103

Line 1052

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

Line 1137

Line 1076

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

ProviderName name(

CIMObjectPath assocPath(

objectPath.toString(),

System::getHostName(),

String::EMPTY,

request->nameSpace,

String::EMPTY,

request->assocClass.getString());

String::EMPTY,

ProviderType::ASSOCIATION);

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

pm_service_op_lock op_lock(&ph.GetProvider());

ph.GetProvider().associatorNames(

Line 1195

Line 1134

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

return(response);

}

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

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

{

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

Line 1208

Line 1149

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

Line 1242

Line 1173

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

ProviderName name(

CIMObjectPath resultPath(

objectPath.toString(),

System::getHostName(),

String::EMPTY,

request->nameSpace,

String::EMPTY,

request->resultClass.getString());

String::EMPTY,

ProviderType::ASSOCIATION);

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

Line 1278

Line 1208

request->role,

request->includeQualifiers,

request->includeClassOrigin,

request->propertyList.getPropertyNameArray(),

request->propertyList,

handler);

STAT_PMS_PROVIDEREND;

Line 1307

Line 1237

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

return(response);

}

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

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

{

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

Line 1320

Line 1252

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

Line 1352

Line 1276

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

ProviderName name(

CIMObjectPath resultPath(

objectPath.toString(),

System::getHostName(),

String::EMPTY,

request->nameSpace,

String::EMPTY,

request->resultClass.getString());

String::EMPTY,

ProviderType::ASSOCIATION);

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

Line 1414

Line 1337

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

return(response);

}

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

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

{

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

Line 1428

Line 1353

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

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

// Set HTTP method in response from request

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

GetPropertyResponseHandler handler(request, response);

try

Line 1459

Line 1374

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;

Line 1523

Line 1432

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

return(response);

}

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

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

{

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

Line 1536

Line 1447

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

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

// Set HTTP method in response from request

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

SetPropertyResponseHandler handler(request, response);

try

Line 1570

Line 1469

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;

Line 1636

Line 1529

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

return(response);

}

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

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

{

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

Line 1650

Line 1545

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

Line 1684

Line 1567

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

Line 1755

Line 1632

return(response);

}

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

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

{

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

Line 1765

Line 1642

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

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

// Set HTTP method in response from request

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

OperationResponseHandler handler(request, response);

try

Line 1800

Line 1668

request->nameSpace.getString(),

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.

String physicalName=_resolvePhysicalName( req_providerModule.getProperty(

// make target object path

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

CIMObjectPath objectPath(

System::getHostName(),

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

request->nameSpace,

physicalName,

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

req_providerModule.getProperty(req_providerModule.findProperty

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

ProviderName name(

objectPath.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(SubscriptionLanguageListContainer::NAME));

context.insert(SubscriptionLanguageListContainer

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

(request->acceptLanguages));

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

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

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

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

Line 1869

Line 1732

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 1897

Line 1777

return(response);

}

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

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

{

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

Line 1907

Line 1787

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

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

// Set HTTP method in response from request

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

OperationResponseHandler handler(request, response);

try

Line 1937

Line 1808

}

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

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

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

System::getHostName(),

request->nameSpace.getString(),

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.

String physicalName=_resolvePhysicalName( req_providerModule.getProperty(

// make target object path

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

CIMObjectPath objectPath(

System::getHostName(),

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

request->nameSpace,

physicalName,

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

req_providerModule.getProperty(req_providerModule.findProperty

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

ProviderName name(

objectPath.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(SubscriptionLanguageListContainer::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 2039

Line 1899

return(response);

}

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

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

{

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

Line 2049

Line 1909

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

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

// Set HTTP method in response from request

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

OperationResponseHandler handler(request, response);

try

Line 2084

Line 1935

request->nameSpace.getString(),

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

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

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

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

Line 2145

Line 1987

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(

request->messageId,

CIMException(),

request->queueIds.copyAndPop());

CIMEnableIndicationsResponseMessage * responseforhandler =

new CIMEnableIndicationsResponseMessage(

request->messageId,

CIMException(),

request->queueIds.copyAndPop());

PEGASUS_ASSERT(response != 0);

// preserve message key

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

// Set HTTP method in response from request

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

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

// ATTN: need pointer to Provider Manager Server!

//EnableIndicationsResponseHandler *handler =

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

try

{

// get the provider file name and logical name

Triad<String, String, String> triad =

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

// get cached or load new provider module

//Provider provider =

OpProviderHolder ph =

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

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"Calling provider.enableIndications: " +

ph.GetProvider().getName());

ph.GetProvider().protect();

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

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

// long as the provider has indications enabled.

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

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

_insertEntry(ph.GetProvider(), handler);

}

catch(CIMException & e)

{

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

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

response->cimException = CIMException(e);

}

catch(Exception & e)

{

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

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

//l10n

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

response->cimException = CIMException(CIM_ERR_FAILED, MessageLoaderParms(

"ProviderManager.DefaultProviderManager.INTERNAL_ERROR",

"Internal Error"));

}

catch(...)

{

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"Exception: Unknown");

//l10n

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

response->cimException = CIMException(CIM_ERR_FAILED, MessageLoaderParms(

"ProviderManager.DefaultProviderManager.UNKNOWN_ERROR",

"Unknown Error"));

}

PEG_METHOD_EXIT();

return(response);

}

// Decrement count of current subscriptions for this provider

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

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

{

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

{

ProviderName name(

String::EMPTY,

0);

ProviderName name(

String::EMPTY,

objectPath.toString());

// resolve provider name

name = _resolveProviderName(name);

// get cached or load new provider module

OpProviderHolder ph =

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

// get the provider file name and logical name

Triad<String, String, String> triad =

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

// get cached or load new provider module

//Provider provider =

OpProviderHolder ph =

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

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"Calling provider.disableIndications: " +

ph.GetProvider().getName());

Line 2333

Line 2008

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 2369

Line 2046

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

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

STAT_GETSTARTTIME

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"Calling provider.: " +

Line 2423

Line 2080

OperationContext context;

//L10N_TODO

//l10n

// ATTN-CEC 06/04/03 NOTE: I can't find where the consume msg is sent. This

// does not appear to be hooked-up. When it is added, need to

// make sure that Content-Language is set in the consume msg.

// NOTE: A-L is not needed to be set in the consume msg.

// add the langs to the context

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

CIMInstance indication_copy = request->indicationInstance;

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

SimpleIndicationResponseHandler handler;

CIMInstance indication_copy = request->indicationInstance;

pm_service_op_lock op_lock(&ph.GetProvider());

ph.GetProvider().consumeIndication(context,

"",

request->destinationPath,

indication_copy);

STAT_PMS_PROVIDEREND

}

catch(CIMException & e)

{

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

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

response->cimException = CIMException(e);

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

}

catch(Exception & e)

{

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

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

//l10n

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

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

response->cimException = CIMException(CIM_ERR_FAILED, MessageLoaderParms(

"ProviderManager.DefaultProviderManager.INTERNAL_ERROR",

"Internal Error"));

}

catch(...)

{

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"Exception: Unknown");

//l10n

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

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

response->cimException = CIMException(CIM_ERR_FAILED, MessageLoaderParms(

"ProviderManager.DefaultProviderManager.UNKNOWN_ERROR",

"Unknown Error"));

}

PEG_METHOD_EXIT();

Line 2472

Line 2128

return(response);

}

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

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

Line 2481

Line 2140

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

Line 2149

PEGASUS_ASSERT(request != 0);

Array<Uint16> operationalStatus;

CIMException cimException;

try

{

// get provider module name

String moduleName;

CIMInstance mInstance = request->providerModule;

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

PEGASUS_ASSERT(pos != PEG_NOT_FOUND);

if(pos != PEG_NOT_FOUND)

{

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

}

Boolean disableProviderOnly = request->disableProviderOnly;

// get operational status

// Unload providers

Array<Uint16> operationalStatus;

Array<CIMInstance> _pInstances = request->providers;

Array<Boolean> _indicationProviders = request->indicationProviders;

String physicalName=_resolvePhysicalName(

mInstance.getProperty(

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

if(!disableProviderOnly)

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;

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

{

/* temp disabled by Chip

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

// get the provider file name and logical name

"Exception: Unknown");

Triad<String, String, String> triad =

//l10n

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

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

cimException = PEGASUS_CIM_EXCEPTION_L(

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

CIM_ERR_FAILED,

MessageLoaderParms(

"ProviderManager.ProviderManagerService.UNKNOWN_ERROR",

"Unknown Error"));

}

if(!disableProviderOnly)

if (cimException.getCode() == CIM_ERR_SUCCESS)

{

// update module status from Stopping to Stopped

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

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

if (operationalStatus.size() == 0)

{

if(operationalStatus[i] == _MODULE_STOPPING)

operationalStatus.append(CIM_MSE_OPSTATUS_VALUE_STOPPED);

{

operationalStatus.remove(i);

}

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 2618

Line 2283

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

}

// update module status from Stopped to OK

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

{

if(operationalStatus[i] == _MODULE_STOPPED)

{

operationalStatus.remove(i);

}

operationalStatus.append(_MODULE_OK);

// get module name

String moduleName;

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

response->operationalStatus = operationalStatus;

if(pos2 != PEG_NOT_FOUND)

PEG_METHOD_EXIT();

{

return(response);

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

}

if(_providerRegistrationManager->setProviderModuleStatus

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

(moduleName, operationalStatus) == false)

{

//l10n

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

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

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, MessageLoaderParms(

"ProviderManager.DefaultProviderManager.SET_MODULE_STATUS_FAILED",

"set module status failed."));

}

CIMEnableModuleResponseMessage * response =

CIMStopAllProvidersRequestMessage * request =

new CIMEnableModuleResponseMessage(

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

request->messageId,

CIMException(),

request->queueIds.copyAndPop(),

operationalStatus);

PEGASUS_ASSERT(response != 0);

PEGASUS_ASSERT(request != 0);

// preserve message key

CIMStopAllProvidersResponseMessage* response =

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

dynamic_cast<CIMStopAllProvidersResponseMessage*>(

request->buildResponse());

PEGASUS_ASSERT(response != 0);

// Set HTTP method in response from request

// tell the provider manager to shutdown all the providers

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

providerManager.shutdownAllProviders();

// And remove all of the response handlers that might have not been

// explicitly stopped.

try {

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

{

EnableIndicationsResponseHandler *handler = i.value();

delete handler;

}

} catch (... ) { }

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

}

Line 2721

Line 2401

const Provider & provider,

const EnableIndicationsResponseHandler *handler)

{

PEG_METHOD_ENTER (TRC_INDICATION_SERVICE,

PEG_METHOD_ENTER (TRC_PROVIDERMANAGER,

"DefaultProviderManager::_insertEntry");

String tableKey = _generateKey

Line 2735

Line 2415

EnableIndicationsResponseHandler * DefaultProviderManager::_removeEntry(

const String & key)

{

PEG_METHOD_ENTER (TRC_INDICATION_SERVICE,

PEG_METHOD_ENTER (TRC_PROVIDERMANAGER,

"DefaultProviderManager::_removeEntry");

EnableIndicationsResponseHandler *ret = 0;

_responseTable.lookup(key, ret);

_responseTable.remove(key); // why is this needed ? - we get killed when removed...

PEG_METHOD_EXIT();

Line 2751

Line 2432

{

String tableKey;

PEG_METHOD_ENTER (TRC_INDICATION_SERVICE,

PEG_METHOD_ENTER (TRC_PROVIDERMANAGER,

"DefaultProviderManager::_generateKey");

Line 2767

Line 2448

return(tableKey);

}

ProviderName DefaultProviderManager::_resolveProviderName(const ProviderName & providerName)

String DefaultProviderManager::_generateKey (

const String & providerName,

const String & providerFileName)

{

ProviderName temp = findProvider(providerName);

String tableKey;

PEG_METHOD_ENTER (TRC_PROVIDERMANAGER,

"DefaultProviderManagerService::_generateKey");

String physicalName = temp.getPhysicalName();

// Append providerName and providerFileName to key

tableKey.append (providerName);

tableKey.append (providerFileName);

// fully qualify physical provider name (module), if not already done so.

PEG_METHOD_EXIT ();

#if defined(PEGASUS_PLATFORM_WIN32_IX86_MSVC)

return tableKey;

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

}

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

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

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

#elif defined(PEGASUS_OS_HPUX)

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

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

#elif defined(PEGASUS_OS_OS400)

// do nothing

#else

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

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

#endif

ProviderName DefaultProviderManager::_resolveProviderName(

const ProviderIdContainer & providerId)

{

String providerName;

String fileName;

String interfaceName;

CIMValue genericValue;

temp.setPhysicalName(physicalName);

genericValue = providerId.getProvider().getProperty(

providerId.getProvider().findProperty("Name")).getValue();

genericValue.get(providerName);

return(temp);

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

OpProviderHolder & ph)

{

PEG_METHOD_ENTER (TRC_PROVIDERMANAGER,

"DefaultProviderManager::_callEnableIndications");

try

{

CIMRequestMessage * request = 0;

CIMResponseMessage * response = 0;

EnableIndicationsResponseHandler * enableHandler =

new EnableIndicationsResponseHandler

(request, response, req_provider, _indicationCallback);

PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"Calling provider.enableIndications: " +

ph.GetProvider ().getName ());

pm_service_op_lock op_lock (& ph.GetProvider ());

ph.GetProvider ().protect ();

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

// Store the handler so it is persistent for as

// long as the provider has indications enabled

PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"Storing indication handler for " +

ph.GetProvider ().getName ());

_insertEntry (ph.GetProvider (), enableHandler);

}

catch (CIMException & e)

{

PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,

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

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

"ProviderManager.Default.DefaultProviderManager."

"ENABLE_INDICATIONS_FAILED",

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

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

}

catch (Exception & e)

{

PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,

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

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

"ProviderManager.Default.DefaultProviderManager."

"ENABLE_INDICATIONS_FAILED",

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

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

}

catch(...)

{

PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,

"Unexpected error in _callEnableIndications");

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

"ProviderManager.Default.DefaultProviderManager."

"ENABLE_INDICATIONS_FAILED_UNKNOWN",

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

ph.GetProvider ().getName ());

}

PEG_METHOD_EXIT ();

}

PEGASUS_NAMESPACE_END

Legend:

Removed from v.1.12
changed lines
	Added in v.1.54

No CVS admin address has been configured