void ProviderAgent::run()
{
PEG_METHOD_ENTER(TRC_PROVIDERAGENT, "ProviderAgent::run");
// Enable the signal handler to terminate gracefully on SIGHUP and SIGTERM
getSigHandle()->registerHandler(PEGASUS_SIGHUP, _terminateSignalHandler);
getSigHandle()->activate(PEGASUS_SIGHUP);
getSigHandle()->registerHandler(PEGASUS_SIGTERM, _terminateSignalHandler);
getSigHandle()->activate(PEGASUS_SIGTERM);
// Restore the SIGCHLD signal behavior to its default action
getSigHandle()->defaultAction(PEGASUS_SIGCHLD);
#ifdef PEGASUS_OS_ZOS
// Establish handling signal send to us on USS shutdown
getSigHandle()->registerHandler(PEGASUS_SIGDANGER, _terminateSignalHandler);
getSigHandle()->activate(PEGASUS_SIGDANGER);
// enable process to receive SIGDANGER on USS shutdown
__shutdown_registration(_SDR_NOTIFY, _SDR_REGPROCESS, _SDR_SENDSIGDANGER);
#endif
#ifdef PEGASUS_OS_PASE
// PASE environment need more signal handler
getSigHandle()->registerHandler(SIGFPE, _synchronousSignalHandler);
getSigHandle()->activate(SIGFPE);
getSigHandle()->registerHandler(SIGILL, _synchronousSignalHandler);
getSigHandle()->activate(SIGILL);
getSigHandle()->registerHandler(SIGSEGV, _synchronousSignalHandler);
getSigHandle()->activate(SIGSEGV);
getSigHandle()->registerHandler(SIGIO, _asynchronousSignalHandler);
getSigHandle()->activate(SIGIO);
#endif
while (!_terminating)
{
Boolean active = true;
try
{
//
// Read and process the next request
//
active = _readAndProcessRequest();
}
catch (Exception& e)
{
PEG_TRACE((TRC_PROVIDERAGENT, Tracer::LEVEL1,
"Unexpected Exception from _readAndProcessRequest(): %s",
(const char*)e.getMessage().getCString()));
_terminating = true;
}
catch (...)
{
PEG_TRACE_CSTRING(TRC_PROVIDERAGENT, Tracer::LEVEL1,
"Unexpected exception from _readAndProcessRequest().");
_terminating = true;
}
if (_terminating)
{
if (!_providersStopped)
{
//
// Stop all providers
//
CIMStopAllProvidersRequestMessage
stopRequest("0", QueueIdStack(0));
AutoPtr<Message> stopResponse(_processRequest(&stopRequest));
// If there are agent threads running exit from here.If provider
// is not responding cimprovagt may loop forever in ThreadPool
// destructor waiting for running threads to become idle.
if (_threadPool.runningCount())
{
PEG_TRACE_CSTRING(TRC_PROVIDERAGENT,
Tracer::LEVEL1,
"Agent threads are running, terminating forcibly.");
exit(1);
}
}
}
else if (!active)
{
//
// Stop agent process when no more providers are loaded
//
try
{
if (!_providerManagerRouter.hasActiveProviders() &&
(_threadPool.runningCount() == 0))
{
PEG_TRACE_CSTRING(TRC_PROVIDERAGENT, Tracer::LEVEL2,
"No active providers. Exiting.");
_terminating = true;
}
else
{
_threadPool.cleanupIdleThreads();
}
}
catch (...)
{
// Do not terminate the agent on this exception
PEG_TRACE_CSTRING(TRC_PROVIDERAGENT, Tracer::LEVEL1,
"Unexpected exception from hasActiveProviders()");
}
}
}
// Notify the cimserver that the provider agent is exiting cleanly.
Uint32 messageLength = 0;
_pipeToServer->writeBuffer((const char*)&messageLength, sizeof(Uint32));
PEG_METHOD_EXIT();
}
void CIMServer::_init()
{
// pre-initialize the hostname.
System::getHostName();
_monitor.reset(new Monitor());
#if (defined(PEGASUS_OS_HPUX) || defined(PEGASUS_OS_LINUX)) \
&& defined(PEGASUS_USE_RELEASE_DIRS)
if (chdir(PEGASUS_CORE_DIR) != 0)
{
PEG_TRACE((TRC_SERVER, Tracer::LEVEL2,
"chdir(\"%s\") failed with errno %d.", PEGASUS_CORE_DIR, errno));
}
#endif
// -- Create a repository:
String repositoryRootPath =
ConfigManager::getHomedPath(
ConfigManager::getInstance()->getCurrentValue("repositoryDir"));
#ifdef DO_NOT_CREATE_REPOSITORY_ON_STARTUP
// If this code is enable, the CIMServer will fail to start
// if the repository directory does not exist. If called,
// the Repository will create an empty repository.
// This check has been disabled to allow cimmof to call
// the CIMServer to build the initial repository.
if (!FileSystem::isDirectory(repositoryRootPath))
{
throw NoSuchDirectory(repositoryRootPath);
}
#endif
_repository = new CIMRepository(repositoryRootPath);
// -- Create a UserManager object:
#ifndef PEGASUS_PAM_AUTHENTICATION
UserManager::getInstance(_repository);
#endif
// -- Create a SCMOClass Cache and set call back for the repository
SCMOClassCache::getInstance()->setCallBack(_scmoClassCache_GetClass);
// -- Create a CIMServerState object:
_serverState.reset(new CIMServerState());
_providerRegistrationManager = new ProviderRegistrationManager(_repository);
// -- Create queue inter-connections:
_providerManager = new ProviderManagerService(
_providerRegistrationManager,
_repository,
DefaultProviderManager::createDefaultProviderManagerCallback);
// Create IndicationHandlerService:
_handlerService = new IndicationHandlerService(_repository);
_cimOperationRequestDispatcher = new CIMOperationRequestDispatcher(
_repository, _providerRegistrationManager);
// Create the control service
_controlService = new ModuleController(PEGASUS_QUEUENAME_CONTROLSERVICE);
// Jump this number up when there are more control providers.
_controlProviders.reserveCapacity(16);
// Create the Configuration control provider
ProviderMessageHandler* configProvider = new ProviderMessageHandler(
"CIMServerControlProvider", "ConfigSettingProvider",
new ConfigSettingProvider(), 0, 0, false);
_controlProviders.append(configProvider);
_controlService->register_module(
PEGASUS_MODULENAME_CONFIGPROVIDER,
configProvider,
controlProviderReceiveMessageCallback);
#ifndef PEGASUS_PAM_AUTHENTICATION
// Create the User/Authorization control provider
ProviderMessageHandler* userAuthProvider = new ProviderMessageHandler(
"CIMServerControlProvider", "UserAuthProvider",
new UserAuthProvider(_repository), 0, 0, false);
_controlProviders.append(userAuthProvider);
_controlService->register_module(
PEGASUS_MODULENAME_USERAUTHPROVIDER,
userAuthProvider,
controlProviderReceiveMessageCallback);
#endif
// Create the Provider Registration control provider
ProviderMessageHandler* provRegProvider = new ProviderMessageHandler(
"CIMServerControlProvider", "ProviderRegistrationProvider",
new ProviderRegistrationProvider(_providerRegistrationManager),
ModuleController::indicationCallback, 0, false);
// Warning: The ProviderRegistrationProvider destructor deletes
// _providerRegistrationManager
_controlProviders.append(provRegProvider);
_controlService->register_module(
PEGASUS_MODULENAME_PROVREGPROVIDER,
provRegProvider,
controlProviderReceiveMessageCallback);
// Create the Shutdown control provider
ProviderMessageHandler* shutdownProvider = new ProviderMessageHandler(
"CIMServerControlProvider", "ShutdownProvider",
new ShutdownProvider(this), 0, 0, false);
_controlProviders.append(shutdownProvider);
_controlService->register_module(
PEGASUS_MODULENAME_SHUTDOWNPROVIDER,
shutdownProvider,
controlProviderReceiveMessageCallback);
// Create the namespace control provider
ProviderMessageHandler* namespaceProvider = new ProviderMessageHandler(
"CIMServerControlProvider", "NamespaceProvider",
new NamespaceProvider(_repository), 0, 0, false);
_controlProviders.append(namespaceProvider);
_controlService->register_module(
PEGASUS_MODULENAME_NAMESPACEPROVIDER,
namespaceProvider,
controlProviderReceiveMessageCallback);
//
// Create a SSLContextManager object
//
_sslContextMgr = new SSLContextManager();
#ifdef PEGASUS_HAS_SSL
// Because this provider allows management of the cimserver truststore
// it needs to be available regardless of the value
// of sslClientVerificationMode config property.
ProviderMessageHandler* certificateProvider = new ProviderMessageHandler(
"CIMServerControlProvider", "CertificateProvider",
new CertificateProvider(_repository, _sslContextMgr),
0, 0, false);
_controlProviders.append(certificateProvider);
_controlService->register_module(
PEGASUS_MODULENAME_CERTIFICATEPROVIDER,
certificateProvider,
controlProviderReceiveMessageCallback);
#endif
#ifndef PEGASUS_DISABLE_PERFINST
// Create the Statistical Data control provider
ProviderMessageHandler* cimomstatdataProvider = new ProviderMessageHandler(
"CIMServerControlProvider", "CIMOMStatDataProvider",
new CIMOMStatDataProvider(), 0, 0, false);
_controlProviders.append(cimomstatdataProvider);
_controlService->register_module(
PEGASUS_MODULENAME_CIMOMSTATDATAPROVIDER,
cimomstatdataProvider,
controlProviderReceiveMessageCallback);
#endif
#ifdef PEGASUS_ENABLE_CQL
// Create the Query Capabilities control provider
ProviderMessageHandler* cimquerycapprovider = new ProviderMessageHandler(
"CIMServerControlProvider", "CIMQueryCapabilitiesProvider",
new CIMQueryCapabilitiesProvider(),
0, 0, false);
_controlProviders.append(cimquerycapprovider);
_controlService->register_module(
PEGASUS_MODULENAME_CIMQUERYCAPPROVIDER,
cimquerycapprovider,
controlProviderReceiveMessageCallback);
#endif
#if defined PEGASUS_ENABLE_INTEROP_PROVIDER
// Create the interop control provider
ProviderMessageHandler* interopProvider = new ProviderMessageHandler(
"CIMServerControlProvider", "InteropProvider",
new InteropProvider(
_repository,
_providerRegistrationManager),
0, 0, false);
_controlProviders.append(interopProvider);
_controlService->register_module(
PEGASUS_MODULENAME_INTEROPPROVIDER,
interopProvider,
controlProviderReceiveMessageCallback);
#endif
_cimOperationResponseEncoder = new CIMOperationResponseEncoder;
//
// get the configured authentication and authorization flags
//
ConfigManager* configManager = ConfigManager::getInstance();
Boolean enableAuthentication = ConfigManager::parseBooleanValue(
configManager->getCurrentValue("enableAuthentication"));
MessageQueue* cimOperationProcessorQueue = 0;
//
// Create Authorization queue only if authentication is enabled
//
if ( enableAuthentication )
{
_cimOperationRequestAuthorizer = new CIMOperationRequestAuthorizer(
_cimOperationRequestDispatcher);
cimOperationProcessorQueue = _cimOperationRequestAuthorizer;
}
else
{
_cimOperationRequestAuthorizer = 0;
cimOperationProcessorQueue = _cimOperationRequestDispatcher;
}
_cimOperationRequestDecoder = new CIMOperationRequestDecoder(
cimOperationProcessorQueue,
_cimOperationResponseEncoder->getQueueId());
_cimExportRequestDispatcher = new CIMExportRequestDispatcher();
_cimExportResponseEncoder = new CIMExportResponseEncoder;
_cimExportRequestDecoder = new CIMExportRequestDecoder(
_cimExportRequestDispatcher,
_cimExportResponseEncoder->getQueueId());
_httpAuthenticatorDelegator = new HTTPAuthenticatorDelegator(
_cimOperationRequestDecoder->getQueueId(),
_cimExportRequestDecoder->getQueueId(),
_repository);
_rsProcessor = new RsProcessor(
cimOperationProcessorQueue,
_repository);
_httpAuthenticatorDelegator->setRsQueueId(
_rsProcessor->getRsRequestDecoderQueueId());
#ifdef PEGASUS_ENABLE_PROTOCOL_WEB
_webServer = new WebServer();
_httpAuthenticatorDelegator->setWebQueueId(
_webServer->getQueueId());
#endif
#ifdef PEGASUS_ENABLE_PROTOCOL_WSMAN
_wsmProcessor = new WsmProcessor(
cimOperationProcessorQueue,
_repository);
_httpAuthenticatorDelegator->setWsmQueueId(
_wsmProcessor->getWsmRequestDecoderQueueId());
#endif
// IMPORTANT-NU-20020513: Indication service must start after ExportService
// otherwise HandlerService started by indicationService will never
// get ExportQueue to export indications for existing subscriptions
_indicationService = new IndicationService(
_repository,
_providerRegistrationManager);
// Build the Control Provider and Service internal routing table. This must
// be called after MessageQueueService initialized and ServiceQueueIds
// installed.
DynamicRoutingTable::buildRoutingTable();
// Enable the signal handler to shutdown gracefully on SIGHUP and SIGTERM
getSigHandle()->registerHandler(PEGASUS_SIGHUP, shutdownSignalHandler);
getSigHandle()->activate(PEGASUS_SIGHUP);
getSigHandle()->registerHandler(PEGASUS_SIGTERM, shutdownSignalHandler);
getSigHandle()->activate(PEGASUS_SIGTERM);
#ifdef PEGASUS_OS_PASE
getSigHandle()->registerHandler(SIGFPE, _synchronousSignalHandler);
getSigHandle()->activate(SIGFPE);
getSigHandle()->registerHandler(SIGILL, _synchronousSignalHandler);
getSigHandle()->activate(SIGILL);
getSigHandle()->registerHandler(SIGSEGV, _synchronousSignalHandler);
getSigHandle()->activate(SIGSEGV);
getSigHandle()->registerHandler(SIGIO, _asynchronousSignalHandler);
getSigHandle()->activate(SIGIO);
#endif
#ifdef PEGASUS_OS_ZOS
// Establish handling signal send to us on USS shutdown
getSigHandle()->registerHandler(PEGASUS_SIGDANGER, shutdownSignalHandler);
getSigHandle()->activate(PEGASUS_SIGDANGER);
// enable process to receive SIGDANGER on USS shutdown
__shutdown_registration(_SDR_NOTIFY, _SDR_REGPROCESS, _SDR_SENDSIGDANGER);
#endif
//
// Set up an additional thread waiting for commands from the
// system console
//
#if defined PEGASUS_OS_ZOS
ZOSConsoleManager::startConsoleWatchThread();
#endif
#ifdef PEGASUS_ENABLE_AUDIT_LOGGER
// Register audit logger initialize callback
AuditLogger::setInitializeCallback(auditLogInitializeCallback);
Boolean enableAuditLog = ConfigManager::parseBooleanValue(
configManager->getCurrentValue("enableAuditLog"));
if (enableAuditLog)
{
AuditLogger::setEnabled(enableAuditLog);
}
#endif
}
