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 }