pegasus/src/Pegasus/ProviderManager2/Attic/OOPProviderManagerRouter.cpp - diff

Return to OOPProviderManagerRouter.cpp CVS log

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

Diff for /pegasus/src/Pegasus/ProviderManager2/Attic/OOPProviderManagerRouter.cpp between version 1.6 and 1.25.2.4

version 1.6, 2005/01/26 23:09:09

version 1.25.2.4, 2006/05/19 17:31:41

Line 1

//%2004////////////////////////////////////////////////////////////////////////

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

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

Line 6

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

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

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

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

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

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

Line 28

Line 32

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

// Jenny Yu, Hewlett-Packard Company (jenny_yu@hp.com)

// Modified By:

// Modified By: Sean Keenan, Hewlett-Packard Company (sean.keenan@hp.com)

// Carol Ann Krug Graves, Hewlett-Packard Company

// (carolann_graves@hp.com)

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

Line 50

Line 56

#if defined (PEGASUS_OS_TYPE_WINDOWS)

#include <windows.h> // For CreateProcess()

#else

#elif defined (PEGASUS_OS_OS400)

# if defined (PEGASUS_OS_OS400)

# include <unistd.cleinc>

#elif defined (PEGASUS_OS_VMS)

# include <perror.h>

# include <climsgdef.h>

# include <stdio.h>

# include <stdlib.h>

# include <string.h>

# include <processes.h>

# include <unixio.h>

# else

# include <unistd.h> // For fork(), exec(), and _exit()

# endif

#include <errno.h>

# include <sys/types.h>

# if defined(PEGASUS_HAS_SIGNALS)

# include <sys/wait.h>

# endif

#endif

#include "OOPProviderManagerRouter.h"

Line 81

Line 97

{

public:

OutstandingRequestEntry(

String messageId_,

String originalMessageId_,

CIMRequestMessage* requestMessage_,

CIMResponseMessage*& responseMessage_,

Semaphore* responseReady_)

: messageId(messageId_),

: originalMessageId(originalMessageId_),

requestMessage(requestMessage_),

responseMessage(responseMessage_),

responseReady(responseReady_)

{

}

String messageId;

/**

A unique value is substituted as the request messageId attribute to

allow responses to be definitively correllated with requests.

The original messageId value is stored here to avoid a race condition

between the processing of a response chunk and the resetting of the

original messageId in the request message.

String originalMessageId;

CIMRequestMessage* requestMessage;

CIMResponseMessage*& responseMessage;

Semaphore* responseReady;

};

Line 109

Line 135

ProviderAgentContainer(

const String & moduleName,

const String & userName,

PEGASUS_INDICATION_CALLBACK indicationCallback);

PEGASUS_INDICATION_CALLBACK_T indicationCallback,

PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback,

Boolean subscriptionInitComplete);

~ProviderAgentContainer();

Line 160

Line 188

with an error result.

Note: The caller must lock the _agentMutex.

@param cleanShutdown Indicates whether the provider agent process

exited cleanly. A value of true indicates that responses have been

sent for all requests that have been processed. A value of false

indicates that one or more requests may have been partially processed.

void _uninitialize(Boolean cleanShutdown);

/**

Performs the processMessage work, but does not retry on a transient

error.

void _uninitialize();

CIMResponseMessage* _processMessage(CIMRequestMessage* request);

/**

Read and process response messages from the Provider Agent until

Line 196

Line 235

Callback function to which all generated indications are sent for

processing.

PEGASUS_INDICATION_CALLBACK _indicationCallback;

PEGASUS_INDICATION_CALLBACK_T _indicationCallback;

/**

Callback function to which response chunks are sent for processing.

PEGASUS_RESPONSE_CHUNK_CALLBACK_T _responseChunkCallback;

/**

Indicates whether the Provider Agent is active.

Line 212

Line 256

AutoPtr<AnonymousPipe> _pipeToAgent;

#if defined(PEGASUS_HAS_SIGNALS)

/**

Process ID of the active Provider Agent.

pid_t _pid;

#endif

/**

The _outstandingRequestTable holds an entry for each request that has

been sent to this Provider Agent for which no response has been

Line 251

Line 302

(active) at one time.

static Uint32 _maxProviderProcesses;

/**

A value indicating that a request message has not been processed.

A CIMResponseMessage pointer with this value indicates that the

corresponding CIMRequestMessage has not been processed. This is

used to indicate that a provider agent exited without starting to

process the request, and that the request should be retried.

static CIMResponseMessage* _REQUEST_NOT_PROCESSED;

/**

Indicates whether the Indication Service has completed initialization.

For more information, please see the description of the

ProviderManagerRouter::_subscriptionInitComplete member variable.

Boolean _subscriptionInitComplete;

};

Uint32 ProviderAgentContainer::_numProviderProcesses = 0;

Mutex ProviderAgentContainer::_numProviderProcessesMutex;

Uint32 ProviderAgentContainer::_maxProviderProcesses = PEG_NOT_FOUND;

// Set this to a value that no valid CIMResponseMessage* will have.

CIMResponseMessage* ProviderAgentContainer::_REQUEST_NOT_PROCESSED =

reinterpret_cast<CIMResponseMessage*>(&_REQUEST_NOT_PROCESSED);

ProviderAgentContainer::ProviderAgentContainer(

const String & moduleName,

const String & userName,

PEGASUS_INDICATION_CALLBACK indicationCallback)

PEGASUS_INDICATION_CALLBACK_T indicationCallback,

PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback,

Boolean subscriptionInitComplete)

: _moduleName(moduleName),

_userName(userName),

_indicationCallback(indicationCallback),

_isInitialized(false)

_responseChunkCallback(responseChunkCallback),

_isInitialized(false),

_subscriptionInitComplete(subscriptionInitComplete)

{

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,

"ProviderAgentContainer::ProviderAgentContainer");

Line 279

Line 355

// Ensure the destructor does not throw an exception

try

{

if (isInitialized())

{

// Stop the responseProcessor thread by closing its connection

_pipeFromAgent->closeReadHandle();

Line 288

Line 366

pegasus_yield();

}

catch (...)

{

}

Line 300

Line 379

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,

"ProviderAgentContainer::_startAgentProcess");

// Serialize the starting of agent processes. If two agent processes are

// started at the same time, they may get copies of each other's pipe

// descriptors. If this happens, the cimserver will not get a pipe read

// error when one of the agent processes exits, because the pipe will

// still be writable by the other process. This locking control needs to

// cover the period from where the pipes are created to where the agent

// ends of the pipes are closed by the cimserver.

static Mutex agentStartupMutex;

AutoMutex lock(agentStartupMutex);

AutoPtr<AnonymousPipe> pipeFromAgent(new AnonymousPipe());

AutoPtr<AnonymousPipe> pipeToAgent(new AnonymousPipe());

Line 361

Line 452

CloseHandle(piProcInfo.hProcess);

CloseHandle(piProcInfo.hThread);

#elif defined (PEGASUS_OS_VMS)

// fork and exec the child process

int status;

status = vfork ();

switch (status)

{

case 0:

try

{

// Execute the cimprovagt program

String agentCommandPath =

ConfigManager::getHomedPath(PEGASUS_PROVIDER_AGENT_PROC_NAME);

CString agentCommandPathCString = agentCommandPath.getCString();

char readHandle[32];

char writeHandle[32];

pipeToAgent->exportReadHandle(readHandle);

pipeFromAgent->exportWriteHandle(writeHandle);

if ((status = execl(agentCommandPathCString, agentCommandPathCString,

readHandle, writeHandle,

(const char*)_moduleName.getCString(), (char*)0)) == -1);

{

// If we're still here, there was an error

Tracer::trace(TRC_DISCARDED_DATA, Tracer::LEVEL2,

"execl() failed. errno = %d.", errno);

_exit(1);

}

catch (...)

{

// There's not much we can do here in no man's land

try

{

PEG_TRACE_STRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,

"Caught exception before calling execl().");

}

catch (...)

{

}

_exit(1);

}

PEG_METHOD_EXIT();

return;

break;

case -1:

Tracer::trace(TRC_PROVIDERMANAGER, Tracer::LEVEL2,

"fork() failed. errno = %d.", errno);

PEG_METHOD_EXIT();

throw Exception(MessageLoaderParms(

"ProviderManager.OOPProviderManagerRouter.CIMPROVAGT_START_FAILED",

"Failed to start cimprovagt \"$0\".",

_moduleName));

break;

default:

// Close our copies of the agent's ends of the pipes

pipeToAgent->closeReadHandle();

pipeFromAgent->closeWriteHandle();

_pipeToAgent.reset(pipeToAgent.release());

_pipeFromAgent.reset(pipeFromAgent.release());

PEG_METHOD_EXIT();

}

#elif defined (PEGASUS_OS_OS400)

//Out of provider support for OS400 goes here when needed.

#else

# ifndef PEGASUS_DISABLE_PROV_USERCTXT

// Get and save the effective user name and the uid/gid for the user

// context of the agent process

String effectiveUserName = System::getEffectiveUserName();

PEGASUS_UID_T newUid = (PEGASUS_UID_T) -1;

PEGASUS_GID_T newGid = (PEGASUS_GID_T) -1;

if (_userName != effectiveUserName)

{

if (!System::lookupUserId(_userName.getCString(), newUid, newGid))

{

throw PEGASUS_CIM_EXCEPTION_L(

CIM_ERR_FAILED,

MessageLoaderParms(

"ProviderManager.OOPProviderManagerRouter."

"USER_CONTEXT_CHANGE_FAILED",

"Unable to change user context to \"$0\".", _userName));

}

# endif

pid_t pid = fork();

if (pid < 0)

{

Line 397

Line 587

pipeToAgent->exportReadHandle(readHandle);

pipeFromAgent->exportWriteHandle(writeHandle);

# ifndef PEGASUS_DISABLE_PROV_USERCTXT

// Set the user context of the Provider Agent process

if (_userName != System::getEffectiveUserName())

if (_userName != effectiveUserName)

{

if (!System::changeUserContext(_userName.getCString()))

if (!System::changeUserContext(newUid, newGid))

{

Tracer::trace(TRC_DISCARDED_DATA, Tracer::LEVEL2,

"System::changeUserContext() failed. userName = %s.",

_userName.getCString());

(const char*)_userName.getCString());

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

Logger::WARNING,

"ProviderManager.OOPProviderManagerRouter."

Line 413

Line 604

_exit(1);

}

# endif

execl(agentCommandPathCString, agentCommandPathCString,

readHandle, writeHandle,

Line 435

Line 627

_exit(1);

}

# if defined(PEGASUS_HAS_SIGNALS)

_pid = pid;

# endif

#endif

Line 487

Line 682

configManager->getPegasusHome(),

configProperties,

System::bindVerbose,

_subscriptionInitComplete,

QueueIdStack()));

Line 505

Line 701

_moduleName));

}

// Do not wait for a response from the Provider Agent. (It isn't coming.)

// Wait for a null response from the Provider Agent indicating it has

// initialized successfully.

CIMMessage* message;

AnonymousPipe::Status readStatus;

{

readStatus = _pipeFromAgent->readMessage(message);

} while (readStatus == AnonymousPipe::STATUS_INTERRUPT);

if (readStatus != AnonymousPipe::STATUS_SUCCESS)

{

PEG_METHOD_EXIT();

throw Exception(MessageLoaderParms(

"ProviderManager.OOPProviderManagerRouter."

"CIMPROVAGT_COMMUNICATION_FAILED",

"Failed to communicate with cimprovagt \"$0\".",

_moduleName));

}

PEGASUS_ASSERT(message == 0);

PEG_METHOD_EXIT();

}

Line 525

Line 741

if (_maxProviderProcesses == PEG_NOT_FOUND)

{

String maxProviderProcesses = ConfigManager::getInstance()->getCurrentValue("maxProviderProcesses");

String maxProviderProcesses = ConfigManager::getInstance()->

getCurrentValue("maxProviderProcesses");

CString maxProviderProcessesString = maxProviderProcesses.getCString();

char* end = 0;

_maxProviderProcesses = strtol(maxProviderProcessesString, &end, 10);

Line 554

Line 771

{

_startAgentProcess();

_sendInitializationData();

_isInitialized = true;

_sendInitializationData();

// Start a thread to read and process responses from the Provider Agent

while (!MessageQueueService::get_thread_pool()->allocate_and_awaken(

ThreadStatus rtn = PEGASUS_THREAD_OK;

this, _responseProcessor))

while ((rtn = MessageQueueService::get_thread_pool()->

allocate_and_awaken(this, _responseProcessor)) !=

PEGASUS_THREAD_OK)

{

if (rtn == PEGASUS_THREAD_INSUFFICIENT_RESOURCES)

{

pegasus_yield();

}

else

{

Logger::put(

Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,

"Not enough threads to process responses from the "

"provider agent.");

Tracer::trace(TRC_PROVIDERMANAGER, Tracer::LEVEL2,

"Could not allocate thread to process responses from the "

"provider agent.");

throw Exception(MessageLoaderParms(

"ProviderManager.OOPProviderManagerRouter."

"CIMPROVAGT_THREAD_ALLOCATION_FAILED",

"Failed to allocate thread for cimprovagt \"$0\".",

_moduleName));

}

catch (...)

{

_isInitialized = false;

// Closing the connection causes the agent process to exit

_pipeToAgent.reset();

_pipeFromAgent.reset();

#if defined(PEGASUS_HAS_SIGNALS)

if (_isInitialized)

{

// Harvest the status of the agent process to prevent a zombie

Boolean keepWaiting = false;

{

pid_t status = waitpid(_pid, 0, 0);

if (status == -1)

{

if (errno == EINTR)

{

keepWaiting = true;

}

else

{

Tracer::trace(TRC_DISCARDED_DATA, Tracer::LEVEL2,

"ProviderAgentContainer::_initialize(): "

"waitpid failed; errno = %d.", errno);

}

} while (keepWaiting);

}

#endif

_isInitialized = false;

{

AutoMutex lock(_numProviderProcessesMutex);

_numProviderProcesses--;

Line 590

Line 856

}

// Note: Caller must lock _agentMutex

void ProviderAgentContainer::_uninitialize()

void ProviderAgentContainer::_uninitialize(Boolean cleanShutdown)

{

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,

"ProviderAgentContainer::_uninitialize");

Line 615

Line 881

_numProviderProcesses--;

}

#if defined(PEGASUS_HAS_SIGNALS)

// Harvest the status of the agent process to prevent a zombie

Boolean keepWaiting = false;

{

pid_t status = waitpid(_pid, 0, 0);

if (status == -1)

{

if (errno == EINTR)

{

keepWaiting = true;

}

else

{

Tracer::trace(TRC_DISCARDED_DATA, Tracer::LEVEL2,

"ProviderAgentContainer::_uninitialize(): "

"waitpid failed; errno = %d.", errno);

}

} while (keepWaiting);

#endif

_isInitialized = false;

Line 622

Line 910

// connection

{

// If not a clean shutdown, log a warning message in case module

// included indication providers

if (!cleanShutdown)

{

Logger::put_l(

Logger::STANDARD_LOG, System::CIMSERVER, Logger::WARNING,

"ProviderManager.OOPProviderManagerRouter."

"OOP_PROVIDER_MODULE_FAILURE_DETECTED",

"A failure was detected in provider module $0. The"

" generation of indications by providers in this module"

" may be affected. To ensure these providers are"

" serving active subscriptions, disable and then"

" re-enable this module using the cimprovider command.",

_moduleName);

}

AutoMutex tableLock(_outstandingRequestTableMutex);

CIMResponseMessage* response =

cleanShutdown ? _REQUEST_NOT_PROCESSED : 0;

for (OutstandingRequestTable::Iterator i =

_outstandingRequestTable.start();

i != 0; i++)

{

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,

String("Completing messageId \"") + i.value()->messageId +

String("Completing messageId \"") + i.key() +

"\" with a null response.");

i.value()->responseMessage = 0;

i.value()->responseMessage = response;

i.value()->responseReady->signal();

}

Line 660

Line 969

"ProviderAgentContainer::processMessage");

CIMResponseMessage* response;

{

response = _processMessage(request);

if (response == _REQUEST_NOT_PROCESSED)

{

// Check for request message types that should not be retried.

if ((request->getType() ==

CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE) ||

(request->getType() ==

CIM_NOTIFY_CONFIG_CHANGE_REQUEST_MESSAGE) ||

(request->getType() ==

CIM_SUBSCRIPTION_INIT_COMPLETE_REQUEST_MESSAGE) ||

(request->getType() ==

CIM_DELETE_SUBSCRIPTION_REQUEST_MESSAGE))

{

response = request->buildResponse();

break;

}

else if (request->getType() == CIM_DISABLE_MODULE_REQUEST_MESSAGE)

{

CIMDisableModuleResponseMessage* dmResponse =

dynamic_cast<CIMDisableModuleResponseMessage*>(response);

PEGASUS_ASSERT(dmResponse != 0);

Array<Uint16> operationalStatus;

operationalStatus.append(CIM_MSE_OPSTATUS_VALUE_STOPPED);

dmResponse->operationalStatus = operationalStatus;

break;

}

} while (response == _REQUEST_NOT_PROCESSED);

PEG_METHOD_EXIT();

return response;

}

CIMResponseMessage* ProviderAgentContainer::_processMessage(

CIMRequestMessage* request)

{

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,

"ProviderAgentContainer::_processMessage");

CIMResponseMessage* response;

String originalMessageId = request->messageId;

// These three variables are used for the provider module optimization.

Line 686

Line 1040

Semaphore waitSemaphore(0);

OutstandingRequestEntry outstandingRequestEntry(

uniqueMessageId, response, &waitSemaphore);

originalMessageId, request, response, &waitSemaphore);

// Lock the Provider Agent Container while initializing the

Line 770

Line 1124

Tracer::trace(TRC_PROVIDERMANAGER, Tracer::LEVEL2,

"Failed to write message to pipe. writeStatus = %d.",

writeStatus);

throw Exception(MessageLoaderParms(

"ProviderManager.OOPProviderManagerRouter."

request->messageId = originalMessageId;

"CIMPROVAGT_COMMUNICATION_FAILED",

"Failed to communicate with cimprovagt \"$0\".",

if (doProviderModuleOptimization)

_moduleName));

{

request->operationContext.set(*origProviderId.get());

}

// Remove this OutstandingRequestTable entry

{

AutoMutex tableLock(_outstandingRequestTableMutex);

Boolean removed =

_outstandingRequestTable.remove(uniqueMessageId);

PEGASUS_ASSERT(removed);

}

// A response value of _REQUEST_NOT_PROCESSED indicates

// that the request was not processed by the provider

// agent, so it can be retried safely.

PEG_METHOD_EXIT();

return _REQUEST_NOT_PROCESSED;

}

if (updateProviderModuleCache)

Line 800

Line 1170

_outstandingRequestTable.remove(uniqueMessageId);

PEGASUS_ASSERT(removed);

}

PEG_METHOD_EXIT();

throw;

}

Line 821

Line 1192

_outstandingRequestTable.remove(uniqueMessageId);

PEGASUS_ASSERT(removed);

}

PEG_METHOD_EXIT();

throw;

}

// A response value of _REQUEST_NOT_PROCESSED indicates that the

// provider agent process was terminating when the request was sent.

// The request was not processed by the provider agent, so it can be

// retried safely.

if (response == _REQUEST_NOT_PROCESSED)

{

PEG_METHOD_EXIT();

return response;

}

// A null response is returned when an agent connection is closed

// while requests remain outstanding.

if (response == 0)

Line 916

Line 1298

(readStatus == AnonymousPipe::STATUS_CLOSED))

{

AutoMutex lock(_agentMutex);

_uninitialize();

_uninitialize(false);

return;

}

// A null message indicates that the provider agent process has

// finished its processing and is ready to exit.

if (message == 0)

{

AutoMutex lock(_agentMutex);

_uninitialize(true);

return;

}

Line 927

Line 1318

reinterpret_cast<CIMProcessIndicationRequestMessage*>(

message));

}

else if (!message->isComplete())

{

CIMResponseMessage* response;

response = dynamic_cast<CIMResponseMessage*>(message);

PEGASUS_ASSERT(response != 0);

// Get the OutstandingRequestEntry for this response chunk

OutstandingRequestEntry* _outstandingRequestEntry = 0;

{

AutoMutex tableLock(_outstandingRequestTableMutex);

Boolean foundEntry = _outstandingRequestTable.lookup(

response->messageId, _outstandingRequestEntry);

PEGASUS_ASSERT(foundEntry);

}

// Put the original message ID into the response

response->messageId =

_outstandingRequestEntry->originalMessageId;

// Call the response chunk callback to process the chunk

_responseChunkCallback(

_outstandingRequestEntry->requestMessage, response);

}

else

{

CIMResponseMessage* response;

Line 963

Line 1377

}

PEG_METHOD_EXIT();

}

PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL

Line 982

Line 1395

/////////////////////////////////////////////////////////////////////////////

OOPProviderManagerRouter::OOPProviderManagerRouter(

PEGASUS_INDICATION_CALLBACK indicationCallback)

PEGASUS_INDICATION_CALLBACK_T indicationCallback,

PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback)

{

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,

"OOPProviderManagerRouter::OOPProviderManagerRouter");

_indicationCallback = indicationCallback;

_responseChunkCallback = responseChunkCallback;

_subscriptionInitComplete = false;

PEG_METHOD_EXIT();

}

Line 1012

Line 1428

PEG_METHOD_EXIT();

}

// Private, unimplemented constructor

OOPProviderManagerRouter::OOPProviderManagerRouter()

{

}

// Private, unimplemented constructor

OOPProviderManagerRouter::OOPProviderManagerRouter(

const OOPProviderManagerRouter&)

: ProviderManagerRouter(*this)

{

}

// Private, unimplemented assignment operator

OOPProviderManagerRouter& OOPProviderManagerRouter::operator=(

const OOPProviderManagerRouter&)

{

return *this;

}

Message* OOPProviderManagerRouter::processMessage(Message* message)

{

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,

Line 1068

Line 1465

providerModule = dmReq->providerModule;

}

else if ((request->getType() == CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE) ||

(request->getType() ==

CIM_SUBSCRIPTION_INIT_COMPLETE_REQUEST_MESSAGE) ||

(request->getType() == CIM_NOTIFY_CONFIG_CHANGE_REQUEST_MESSAGE))

{

// This operation is not provider-specific

Line 1095

Line 1494

// Just let the selecting thread notice when the agent connections

// are closed.

}

else if (request->getType () ==

CIM_SUBSCRIPTION_INIT_COMPLETE_REQUEST_MESSAGE)

{

_subscriptionInitComplete = true;

// Forward the CIMSubscriptionInitCompleteRequestMessage to

// all providers

response.reset (_forwardRequestToAllAgents (request));

}

else if (request->getType() == CIM_NOTIFY_CONFIG_CHANGE_REQUEST_MESSAGE)

{

CIMNotifyConfigChangeRequestMessage* notifyRequest =

Line 1262

Line 1672

PEGASUS_PROPERTYNAME_MODULE_USERCONTEXT);

if (pos != PEG_NOT_FOUND)

{

providerModule.getProperty(pos).getValue().get(userContext);

CIMValue userContextValue =

providerModule.getProperty(pos).getValue();

if (!userContextValue.isNull())

{

userContextValue.get(userContext);

}

if (userContext == 0)

Line 1281

Line 1696

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

userName = ic.getUserName();

}

catch (Exception& e)

catch (Exception&)

{

// If no IdentityContainer is present, default to the CIM

// Server's user context

Line 1344

Line 1759

if (!_providerAgentTable.lookup(key, pa))

{

pa = new ProviderAgentContainer(

moduleName, userName, _indicationCallback);

moduleName, userName, _indicationCallback, _responseChunkCallback,

_subscriptionInitComplete);

_providerAgentTable.insert(key, pa);

}

return pa;

Legend:

Removed from v.1.6
changed lines
	Added in v.1.25.2.4

No CVS admin address has been configured