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.10 and 1.25.2.2

version 1.10, 2005/02/08 22:39:32

version 1.25.2.2, 2006/03/15 21:28:36

Line 1

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

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

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

Line 8

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

Line 33

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

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

// Carol Ann Krug Graves, Hewlett-Packard Company

// (carolann_graves@hp.com)

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

Line 65

Line 69

#else

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

# include <errno.h>

# include <sys/types.h>

# if defined(PEGASUS_HAS_SIGNALS)

# include <sys/wait.h>

# endif

#endif

#include "OOPProviderManagerRouter.h"

Line 90

Line 98

public:

OutstandingRequestEntry(

String messageId_,

CIMRequestMessage* requestMessage_,

CIMResponseMessage*& responseMessage_,

Semaphore* responseReady_)

: messageId(messageId_),

requestMessage(requestMessage_),

responseMessage(responseMessage_),

responseReady(responseReady_)

{

}

String messageId;

CIMRequestMessage* requestMessage;

CIMResponseMessage*& responseMessage;

Semaphore* responseReady;

};

Line 117

Line 128

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 168

Line 181

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

void _uninitialize(Boolean cleanShutdown);

/**

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

error.

CIMResponseMessage* _processMessage(CIMRequestMessage* request);

/**

Read and process response messages from the Provider Agent until

Line 204

Line 228

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 220

Line 249

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 259

Line 295

(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 287

Line 348

// Ensure the destructor does not throw an exception

try

{

if (isInitialized())

{

// Stop the responseProcessor thread by closing its connection

_pipeFromAgent->closeReadHandle();

Line 296

Line 359

pegasus_yield();

}

catch (...)

{

}

Line 308

Line 372

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 442

Line 518

PEG_METHOD_EXIT();

}

#elif defined (PEGASUS_OS_OS400)

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

#else

pid_t pid = fork();

if (pid < 0)

Line 478

Line 558

pipeToAgent->exportReadHandle(readHandle);

pipeFromAgent->exportWriteHandle(writeHandle);

#ifndef PEGASUS_DISABLE_PROV_USERCTXT

// Set the user context of the Provider Agent process

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

{

Line 494

Line 575

_exit(1);

}

#endif

execl(agentCommandPathCString, agentCommandPathCString,

readHandle, writeHandle,

Line 516

Line 598

_exit(1);

}

# if defined(PEGASUS_HAS_SIGNALS)

_pid = pid;

# endif

#endif

Line 529

Line 614

_pipeToAgent.reset(pipeToAgent.release());

_pipeFromAgent.reset(pipeFromAgent.release());

#if defined (PEGASUS_OS_VMS)

// Denote end of switch

}

#endif

PEG_METHOD_EXIT();

}

Line 575

Line 653

configManager->getPegasusHome(),

configProperties,

System::bindVerbose,

_subscriptionInitComplete,

QueueIdStack()));

Line 593

Line 672

_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 613

Line 712

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 642

Line 742

{

_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 678

Line 827

}

// Note: Caller must lock _agentMutex

void ProviderAgentContainer::_uninitialize()

void ProviderAgentContainer::_uninitialize(Boolean cleanShutdown)

{

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,

"ProviderAgentContainer::_uninitialize");

Line 703

Line 852

_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 710

Line 881

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

Line 719

Line 911

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,

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

"\" with a null response.");

i.value()->responseMessage = 0;

i.value()->responseMessage = response;

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

}

Line 748

Line 940

"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 774

Line 1011

Semaphore waitSemaphore(0);

OutstandingRequestEntry outstandingRequestEntry(

uniqueMessageId, response, &waitSemaphore);

uniqueMessageId, request, response, &waitSemaphore);

// Lock the Provider Agent Container while initializing the

Line 858

Line 1095

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 888

Line 1141

_outstandingRequestTable.remove(uniqueMessageId);

PEGASUS_ASSERT(removed);

}

PEG_METHOD_EXIT();

throw;

}

Line 909

Line 1163

_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 1004

Line 1269

(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 1015

Line 1289

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->requestMessage->messageId;

// Call the response chunk callback to process the chunk

_responseChunkCallback(

_outstandingRequestEntry->requestMessage, response);

}

else

{

CIMResponseMessage* response;

Line 1051

Line 1348

}

PEG_METHOD_EXIT();

}

PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL

Line 1070

Line 1366

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

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 1100

Line 1399

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 1156

Line 1436

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 1183

Line 1465

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

Line 1643

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 1432

Line 1730

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.10
changed lines
	Added in v.1.25.2.2

No CVS admin address has been configured