version 1.202, 2007/06/19 17:58:04
|
version 1.203, 2007/06/22 17:35:53
|
|
|
#include <Pegasus/Common/Constants.h> | #include <Pegasus/Common/Constants.h> |
#include <Pegasus/Common/PegasusAssert.h> | #include <Pegasus/Common/PegasusAssert.h> |
#include <Pegasus/Common/FileSystem.h> | #include <Pegasus/Common/FileSystem.h> |
#include <Pegasus/Common/Monitor.h> |
|
#include <Pegasus/Common/PegasusVersion.h> | #include <Pegasus/Common/PegasusVersion.h> |
#include <Pegasus/Common/Logger.h> | #include <Pegasus/Common/Logger.h> |
#include <Pegasus/Common/System.h> | #include <Pegasus/Common/System.h> |
|
|
{ | { |
public: | public: |
| |
CIMServerProcess(void) |
CIMServerProcess() |
{ | { |
cimserver_set_process(this); | cimserver_set_process(this); |
} | } |
| |
virtual ~CIMServerProcess(void) |
virtual ~CIMServerProcess() |
{ | { |
} | } |
| |
|
|
return PEGASUS_PROCESS_NAME; | return PEGASUS_PROCESS_NAME; |
} | } |
| |
//defined in Constants.h |
|
virtual const char* getPIDFileName() const |
|
{ |
|
return PEGASUS_CIMSERVER_START_FILE; |
|
} |
|
|
|
int cimserver_run( | int cimserver_run( |
int argc, | int argc, |
char** argv, | char** argv, |
Boolean shutdownOption, | Boolean shutdownOption, |
Boolean debugOutputOption); | Boolean debugOutputOption); |
| |
void cimserver_stop(void); |
void cimserver_stop(); |
}; | }; |
| |
ServerRunStatus _serverRunStatus( | ServerRunStatus _serverRunStatus( |
PEGASUS_PROCESS_NAME, PEGASUS_CIMSERVER_START_FILE); | PEGASUS_PROCESS_NAME, PEGASUS_CIMSERVER_START_FILE); |
AutoPtr<CIMServerProcess> _cimServerProcess(new CIMServerProcess()); | AutoPtr<CIMServerProcess> _cimServerProcess(new CIMServerProcess()); |
static CIMServer* _cimServer = 0; | static CIMServer* _cimServer = 0; |
static Monitor* _monitor = 0; |
|
static Thread* dummyInitialThread = 0; | static Thread* dummyInitialThread = 0; |
|
|
// | // |
// The command name. | // The command name. |
// | // |
|
|
| |
static const char OPTION_DEBUGOUTPUT = 'X'; | static const char OPTION_DEBUGOUTPUT = 'X'; |
| |
static const String PROPERTY_TIMEOUT = "shutdownTimeout"; |
|
|
|
ConfigManager* configManager; |
|
|
|
/** GetOptions function - This function defines the Options Table | /** GetOptions function - This function defines the Options Table |
and sets up the options from that table using the config manager. | and sets up the options from that table using the config manager. |
| |
|
|
// destructors to get called. | // destructors to get called. |
void deleteCIMServer() | void deleteCIMServer() |
{ | { |
if (_cimServer) |
|
{ |
|
delete _cimServer; | delete _cimServer; |
_cimServer = 0; | _cimServer = 0; |
| |
#if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_OS_LINUX) || \ |
|
defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM) || defined(PEGASUS_OS_AIX) || \ |
|
defined(PEGASUS_OS_SOLARIS) || defined(PEGASUS_OS_VMS) |
|
// |
|
// Remove the PID file to indicate CIMServer termination |
|
// |
|
FileSystem::removeFile(_cimServerProcess->getPIDFileName()); |
|
#endif |
|
} |
|
|
|
delete _monitor; |
|
|
|
if (dummyInitialThread) | if (dummyInitialThread) |
{ | { |
Thread::clearLanguages(); | Thread::clearLanguages(); |
|
|
Boolean shutdownOption, | Boolean shutdownOption, |
Boolean debugOutputOption) | Boolean debugOutputOption) |
{ | { |
String logsDirectory; |
|
Boolean daemonOption = false; | Boolean daemonOption = false; |
| |
// | // |
// Get an instance of the Config Manager. | // Get an instance of the Config Manager. |
// | // |
configManager = ConfigManager::getInstance(); |
ConfigManager* configManager = ConfigManager::getInstance(); |
configManager->useConfigFiles = true; | configManager->useConfigFiles = true; |
| |
|
try |
|
{ |
// | // |
// Get options (from command line and from configuration file); this | // Get options (from command line and from configuration file); this |
// removes corresponding options and their arguments from the command | // removes corresponding options and their arguments from the command |
// line. |
// line. NOTE: If shutdownOption=true, the contents of current config |
|
// file are not overwritten by the planned config file. |
// | // |
try |
|
{ |
|
// If current process is "cimserver -s" (shutdown option = true) the |
|
// contents of current config should not be overwritten by planned |
|
// config |
|
GetOptions(configManager, argc, argv, shutdownOption); | GetOptions(configManager, argc, argv, shutdownOption); |
} |
|
catch (Exception& e) |
|
{ |
|
Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE, |
|
"src.Server.cimserver.SERVER_NOT_STARTED", |
|
"cimserver not started: $0", e.getMessage()); |
|
|
|
MessageLoaderParms parms("src.Server.cimserver.SERVER_NOT_STARTED", |
|
"cimserver not started: $0", e.getMessage()); |
|
| |
PEGASUS_STD(cerr) << argv[0] << ": " << MessageLoader::getMessage(parms) |
// |
<< PEGASUS_STD(endl); |
// Initialize the message home directory in the MessageLoader. |
|
// This is the default directory where the resource bundles are found. |
return(1); |
// |
} |
|
|
|
// Set the home directory, msg sub-dir, into the MessageLoader. |
|
// This will be the default directory where the resource bundles |
|
// are found. |
|
MessageLoader::setPegasusMsgHome(ConfigManager::getHomedPath( | MessageLoader::setPegasusMsgHome(ConfigManager::getHomedPath( |
ConfigManager::getInstance()->getCurrentValue("messageDir"))); | ConfigManager::getInstance()->getCurrentValue("messageDir"))); |
| |
Boolean enableHttpConnection = ConfigManager::parseBooleanValue( |
|
configManager->getCurrentValue("enableHttpConnection")); |
|
Boolean enableHttpsConnection = ConfigManager::parseBooleanValue( |
|
configManager->getCurrentValue("enableHttpsConnection")); |
|
|
|
// Make sure at least one connection is enabled |
|
#ifdef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET |
|
if (!enableHttpConnection && !enableHttpsConnection) |
|
{ |
|
Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, Logger::WARNING, |
|
"src.Server.cimserver.HTTP_NOT_ENABLED_SERVER_NOT_STARTING", |
|
"Neither HTTP nor HTTPS connection is enabled. CIMServer will " |
|
"not be started."); |
|
MessageLoaderParms parms( |
|
"src.Server.cimserver.HTTP_NOT_ENABLED_SERVER_NOT_STARTING", |
|
"Neither HTTP nor HTTPS connection is enabled. CIMServer will " |
|
"not be started."); |
|
cerr << MessageLoader::getMessage(parms) << endl; |
|
return(1); |
|
} |
|
#endif |
|
|
|
try |
|
{ |
|
// | // |
// Check to see if we should start Pegasus as a daemon | // Check to see if we should start Pegasus as a daemon |
// | // |
|
|
daemonOption = ConfigManager::parseBooleanValue( | daemonOption = ConfigManager::parseBooleanValue( |
configManager->getCurrentValue("daemon")); | configManager->getCurrentValue("daemon")); |
| |
#if !defined(PEGASUS_USE_SYSLOGS) | #if !defined(PEGASUS_USE_SYSLOGS) |
logsDirectory = |
String logsDirectory = ConfigManager::getHomedPath( |
ConfigManager::getHomedPath(configManager->getCurrentValue("logdir")); |
configManager->getCurrentValue("logdir")); |
#endif |
|
| |
// Set up the Logger. This does not open the logs |
// Set up the Logger. This does not open the logs. |
// Might be more logical to clean before set. | // Might be more logical to clean before set. |
// ATTN: Need tool to completely disable logging. |
|
|
|
#if !defined(PEGASUS_OS_HPUX) && !defined(PEGASUS_PLATFORM_LINUX_IA64_GNU) && \ |
|
!defined(PEGASUS_USE_SYSLOGS) |
|
Logger::setHomeDirectory(logsDirectory); | Logger::setHomeDirectory(logsDirectory); |
#endif | #endif |
| |
|
|
cout << MessageLoader::getMessage(parms) << logsDirectory << endl; | cout << MessageLoader::getMessage(parms) << logsDirectory << endl; |
#endif | #endif |
} | } |
catch (UnrecognizedConfigProperty& e) |
catch (Exception& e) |
{ |
|
// UnrecognizedConfigProperty is already translated |
|
// thus, just output the message |
|
Logger::put(Logger::ERROR_LOG, |
|
System::CIMSERVER, |
|
Logger::SEVERE, |
|
e.getMessage()); |
|
cout << e.getMessage() << endl; |
|
} |
|
catch (Exception& ex) |
|
{ | { |
Logger::put(Logger::ERROR_LOG, |
MessageLoaderParms parms("src.Server.cimserver.SERVER_NOT_STARTED", |
System::CIMSERVER, |
"cimserver not started: $0", e.getMessage()); |
Logger::SEVERE, |
Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE, |
ex.getMessage()); |
MessageLoader::getMessage(parms)); |
cout << ex.getMessage() << endl; |
cerr << MessageLoader::getMessage(parms) << endl; |
exit(1); |
|
|
return 1; |
} | } |
| |
#if defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM) && defined(PEGASUS_ZOS_SECURITY) | #if defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM) && defined(PEGASUS_ZOS_SECURITY) |
|
|
startupEnableMSC(); | startupEnableMSC(); |
#endif | #endif |
| |
// Bug 2148 - Here is the order of operations for determining the server |
|
// HTTP and HTTPS ports. |
|
// 1) If the user explicitly specified a port, use it. |
|
// 2) If the user did not specify a port, get the port from the services |
|
// file. |
|
// 3) If no value is specified in the services file, use the IANA WBEM |
|
// default port. |
|
// Note that 2 and 3 are done within the System::lookupPort method |
|
// An empty string from the ConfigManager implies that the user did not |
|
// specify a port. |
|
|
|
Uint32 portNumberHttps = 0; |
|
Uint32 portNumberHttp = 0; |
|
Uint32 portNumberExportHttps = 0; |
|
|
|
if (enableHttpsConnection) |
|
{ |
|
String httpsPort = configManager->getCurrentValue("httpsPort"); |
|
if (httpsPort == String::EMPTY) |
|
{ |
|
// |
|
// Look up the WBEM-HTTPS port number |
|
// |
|
portNumberHttps = System::lookupPort( |
|
WBEM_HTTPS_SERVICE_NAME, WBEM_DEFAULT_HTTPS_PORT); |
|
} |
|
else |
|
{ |
|
// |
|
// user-specified |
|
// |
|
CString portString = httpsPort.getCString(); |
|
char* end = 0; |
|
portNumberHttps = strtol(portString, &end, 10); |
|
if (!(end != 0 && *end == '\0')) |
|
{ |
|
InvalidPropertyValue e("httpsPort", httpsPort); |
|
Logger::put_l( |
|
Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE, |
|
"src.Server.cimserver.SERVER_NOT_STARTED", |
|
"cimserver not started: $0", |
|
e.getMessage()); |
|
MessageLoaderParms parms( |
|
"src.Server.cimserver.SERVER_NOT_STARTED", |
|
"cimserver not started: $0", |
|
e.getMessage()); |
|
PEGASUS_STD(cerr) << argv[0] << ": " << |
|
MessageLoader::getMessage(parms) << PEGASUS_STD(endl); |
|
exit(1); |
|
} |
|
} |
|
} |
|
|
|
if (enableHttpConnection) |
|
{ |
|
String httpPort = configManager->getCurrentValue("httpPort"); |
|
if (httpPort == String::EMPTY) |
|
{ |
|
// |
|
// Look up the WBEM-HTTP port number |
|
// |
|
portNumberHttp = System::lookupPort( |
|
WBEM_HTTP_SERVICE_NAME, WBEM_DEFAULT_HTTP_PORT); |
|
} |
|
else |
|
{ |
|
// |
|
// user-specified |
|
// |
|
CString portString = httpPort.getCString(); |
|
char* end = 0; |
|
portNumberHttp = strtol(portString, &end, 10); |
|
if (!(end != 0 && *end == '\0')) |
|
{ |
|
InvalidPropertyValue e("httpPort", httpPort); |
|
Logger::put_l( |
|
Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE, |
|
"src.Server.cimserver.SERVER_NOT_STARTED", |
|
"cimserver not started: $0", |
|
e.getMessage()); |
|
MessageLoaderParms parms( |
|
"src.Server.cimserver.SERVER_NOT_STARTED", |
|
"cimserver not started: $0", |
|
e.getMessage()); |
|
PEGASUS_STD(cerr) << argv[0] << ": " << |
|
MessageLoader::getMessage(parms) << PEGASUS_STD(endl); |
|
exit(1); |
|
} |
|
} |
|
} |
|
|
|
#if defined(PEGASUS_DEBUG) | #if defined(PEGASUS_DEBUG) |
// Put out startup up message. | // Put out startup up message. |
cout << _cimServerProcess->getProductName() << " " << | cout << _cimServerProcess->getProductName() << " " << |
_cimServerProcess->getCompleteVersion() << endl; | _cimServerProcess->getCompleteVersion() << endl; |
MessageLoaderParms parms("src.Server.cimserver.STARTUP_MESSAGE", |
|
"Built $0 $1\nStarting...", |
|
__DATE__, |
|
__TIME__); |
|
#endif | #endif |
| |
// reset message loading to NON-process locale | // reset message loading to NON-process locale |
|
|
umask(S_IRWXG|S_IRWXO); | umask(S_IRWXG|S_IRWXO); |
#endif | #endif |
| |
|
// Start up the CIM Server |
| |
|
try |
|
{ |
#if defined(PEGASUS_OS_TYPE_UNIX) | #if defined(PEGASUS_OS_TYPE_UNIX) |
// | // |
// CRITICAL SECTION BEGIN |
// Lock the CIMSERVER_LOCK_FILE during CIM Server start-up to prevent |
|
// concurrent writes to this file by multiple cimserver processes |
|
// starting at the same time. |
// | // |
// This is the beginning of the critical section regarding the |
CString startupLockFileName = ConfigManager::getHomedPath( |
// access to pidfile (file to indicate that the cimserver has started). |
CIMSERVER_LOCK_FILE).getCString(); |
// Sometimes, when 2 or more cimserver processes are started at the same |
|
// time, they can't detect the concurrent process execution because the |
|
// logic fails when pidfile is accessed concurrently. |
|
| |
|
// Make sure the start-up lock file exists |
FILE* startupLockFile; | FILE* startupLockFile; |
|
if ((startupLockFile = fopen(startupLockFileName, "w")) != 0) |
if ((startupLockFile = fopen(ConfigManager::getHomedPath( |
|
CIMSERVER_LOCK_FILE).getCString(), "w")) != 0) |
|
{ | { |
lockf(fileno(startupLockFile), F_LOCK, 0); |
fclose(startupLockFile); |
} | } |
#endif |
|
| |
#if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) \ |
AutoFileLock fileLock(startupLockFileName); |
|| defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM) || defined(PEGASUS_OS_AIX) \ |
#endif |
|| defined(PEGASUS_OS_SOLARIS) || defined (PEGASUS_OS_VMS) |
|
| |
|
#if defined(PEGASUS_OS_TYPE_UNIX) || defined(PEGASUS_OS_VMS) |
// | // |
// check if CIMServer is already running |
// Check if a CIM Server is already running. If so, print an error |
// if CIMServer is already running, print message and |
// message and notify the parent process (if there is one) to terminate |
// notify parent process (if there is a parent process) to terminate |
|
// | // |
if (_serverRunStatus.isServerRunning()) | if (_serverRunStatus.isServerRunning()) |
{ | { |
MessageLoaderParms parms( | MessageLoaderParms parms( |
"src.Server.cimserver.UNABLE_TO_START_SERVER_ALREADY_RUNNING", | "src.Server.cimserver.UNABLE_TO_START_SERVER_ALREADY_RUNNING", |
"Unable to start CIMServer. CIMServer is already running."); | "Unable to start CIMServer. CIMServer is already running."); |
PEGASUS_STD(cerr) << MessageLoader::getMessage(parms) << |
Logger::put( |
PEGASUS_STD(endl); |
Logger::ERROR_LOG, System::CIMSERVER, Logger::INFORMATION, |
Logger::put(Logger::ERROR_LOG,System::CIMSERVER,Logger::INFORMATION, |
|
MessageLoader::getMessage(parms)); | MessageLoader::getMessage(parms)); |
|
cerr << MessageLoader::getMessage(parms) << endl; |
| |
// |
|
// notify parent process (if there is a parent process) to terminate |
|
// |
|
if (daemonOption) | if (daemonOption) |
{ | { |
_cimServerProcess->notify_parent(1); | _cimServerProcess->notify_parent(1); |
|
|
return 1; | return 1; |
} | } |
| |
|
// |
|
// Declare ourselves as the running CIM Server process, and write our |
|
// PID to the PID file. |
|
// |
|
_serverRunStatus.setServerRunning(); |
#endif | #endif |
| |
// try loop to bind the address, and run the server |
// Create and initialize the CIMServer object |
try |
|
{ |
|
_monitor = new Monitor(); |
|
_cimServer = new CIMServer(_monitor); |
|
| |
if (enableHttpConnection) |
_cimServer = new CIMServer(); |
{ |
|
_cimServer->addAcceptor(false, portNumberHttp, false); |
|
| |
Logger::put_l( |
Boolean enableHttpConnection = ConfigManager::parseBooleanValue( |
Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION, |
configManager->getCurrentValue("enableHttpConnection")); |
"src.Server.cimserver.LISTENING_ON_HTTP_PORT", |
Boolean enableHttpsConnection = ConfigManager::parseBooleanValue( |
"Listening on HTTP port $0.", portNumberHttp); |
configManager->getCurrentValue("enableHttpsConnection")); |
} |
|
| |
if (enableHttpsConnection) |
#ifdef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET |
|
// Make sure at least one connection is enabled |
|
if (!enableHttpConnection && !enableHttpsConnection) |
{ | { |
_cimServer->addAcceptor(false, portNumberHttps, true); |
MessageLoaderParms parms( |
|
"src.Server.cimserver.HTTP_NOT_ENABLED_SERVER_NOT_STARTING", |
Logger::put_l( |
"Neither HTTP nor HTTPS connection is enabled."); |
Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION, |
throw Exception(parms); |
"src.Server.cimserver.LISTENING_ON_HTTPS_PORT", |
|
"Listening on HTTPS port $0.", portNumberHttps); |
|
} | } |
|
|
#ifndef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET |
|
_cimServer->addAcceptor(true, 0, false); |
|
|
|
Logger::put_l( |
|
Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION, |
|
"src.Server.cimserver.LISTENING_ON_LOCAL", |
|
"Listening on local connection socket."); |
|
#endif | #endif |
| |
#if defined(PEGASUS_DEBUG) |
// The server HTTP and HTTPS ports are determined via this algorithm: |
|
// 1) If the user explicitly specified a port, use it. |
|
// 2) If the user did not specify a port, get the port from the |
|
// services file. |
|
// 3) If no value is specified in the services file, use the IANA WBEM |
|
// default port. |
|
// Note that 2 and 3 are done within the System::lookupPort method |
|
// An empty string from the ConfigManager implies that the user did not |
|
// specify a port. |
|
|
if (enableHttpConnection) | if (enableHttpConnection) |
{ | { |
|
Uint32 portNumberHttp = 0; |
|
String httpPort = configManager->getCurrentValue("httpPort"); |
|
if (httpPort == String::EMPTY) |
|
{ |
|
// |
|
// Look up the WBEM-HTTP port number |
|
// |
|
portNumberHttp = System::lookupPort( |
|
WBEM_HTTP_SERVICE_NAME, WBEM_DEFAULT_HTTP_PORT); |
|
} |
|
else |
|
{ |
|
// |
|
// user-specified |
|
// |
|
CString portString = httpPort.getCString(); |
|
char* end = 0; |
|
portNumberHttp = strtol(portString, &end, 10); |
|
if (!(end != 0 && *end == '\0')) |
|
{ |
|
throw InvalidPropertyValue("httpPort", httpPort); |
|
} |
|
} |
|
|
|
_cimServer->addAcceptor(false, portNumberHttp, false); |
|
|
MessageLoaderParms parms( | MessageLoaderParms parms( |
"src.Server.cimserver.LISTENING_ON_HTTP_PORT", | "src.Server.cimserver.LISTENING_ON_HTTP_PORT", |
"Listening on HTTP port $0.", portNumberHttp); | "Listening on HTTP port $0.", portNumberHttp); |
|
Logger::put( |
|
Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION, |
|
MessageLoader::getMessage(parms)); |
|
#if defined(PEGASUS_DEBUG) |
cout << MessageLoader::getMessage(parms) << endl; | cout << MessageLoader::getMessage(parms) << endl; |
|
#endif |
} | } |
|
|
if (enableHttpsConnection) | if (enableHttpsConnection) |
{ | { |
|
Uint32 portNumberHttps = 0; |
|
String httpsPort = configManager->getCurrentValue("httpsPort"); |
|
if (httpsPort == String::EMPTY) |
|
{ |
|
// |
|
// Look up the WBEM-HTTPS port number |
|
// |
|
portNumberHttps = System::lookupPort( |
|
WBEM_HTTPS_SERVICE_NAME, WBEM_DEFAULT_HTTPS_PORT); |
|
} |
|
else |
|
{ |
|
// |
|
// user-specified |
|
// |
|
CString portString = httpsPort.getCString(); |
|
char* end = 0; |
|
portNumberHttps = strtol(portString, &end, 10); |
|
if (!(end != 0 && *end == '\0')) |
|
{ |
|
throw InvalidPropertyValue("httpsPort", httpsPort); |
|
} |
|
} |
|
|
|
_cimServer->addAcceptor(false, portNumberHttps, true); |
|
|
MessageLoaderParms parms( | MessageLoaderParms parms( |
"src.Server.cimserver.LISTENING_ON_HTTPS_PORT", | "src.Server.cimserver.LISTENING_ON_HTTPS_PORT", |
"Listening on HTTPS port $0.", portNumberHttps); | "Listening on HTTPS port $0.", portNumberHttps); |
|
Logger::put( |
|
Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION, |
|
MessageLoader::getMessage(parms)); |
|
#if defined(PEGASUS_DEBUG) |
cout << MessageLoader::getMessage(parms) << endl; | cout << MessageLoader::getMessage(parms) << endl; |
|
#endif |
} | } |
| |
# ifndef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET | # ifndef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET |
|
{ |
|
_cimServer->addAcceptor(true, 0, false); |
|
|
MessageLoaderParms parms( | MessageLoaderParms parms( |
"src.Server.cimserver.LISTENING_ON_LOCAL", | "src.Server.cimserver.LISTENING_ON_LOCAL", |
"Listening on local connection socket."); | "Listening on local connection socket."); |
|
Logger::put( |
|
Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION, |
|
MessageLoader::getMessage(parms)); |
|
# if defined(PEGASUS_DEBUG) |
cout << MessageLoader::getMessage(parms) << endl; | cout << MessageLoader::getMessage(parms) << endl; |
# endif | # endif |
|
} |
#endif | #endif |
| |
_cimServer->bind(); | _cimServer->bind(); |
|
|
#endif | #endif |
} | } |
| |
#if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_OS_LINUX) || \ |
|
defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM) || defined(PEGASUS_OS_AIX) || \ |
|
defined(PEGASUS_OS_SOLARIS) || defined(PEGASUS_OS_VMS) |
|
// |
|
// create a file to indicate that the cimserver has started and |
|
// save the process id of the cimserver process in the file |
|
// |
|
_serverRunStatus.setServerRunning(); |
|
#endif |
|
|
|
#if defined(PEGASUS_DEBUG) | #if defined(PEGASUS_DEBUG) |
cout << "Started. " << endl; | cout << "Started. " << endl; |
#endif | #endif |
| |
#if defined(PEGASUS_OS_TYPE_UNIX) |
|
// |
|
// CRITICAL SECTION END |
|
// |
|
// Here is the unlock of file 'lock_file'. It closes the |
|
// the critical section that guarantees the non concurrent access to |
|
// pid file (file to indicate that the cimserver has started). |
|
// |
|
|
|
if (startupLockFile) |
|
{ |
|
lockf(fileno(startupLockFile), F_ULOCK, 0); |
|
fclose(startupLockFile); |
|
} |
|
#endif |
|
|
|
|
|
// Put server started message to the logger | // Put server started message to the logger |
Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, | Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, |
Logger::INFORMATION, | Logger::INFORMATION, |
|
|
open("/dev/null", O_RDWR); | open("/dev/null", O_RDWR); |
} | } |
#endif | #endif |
|
} |
|
catch (Exception& e) |
|
{ |
|
MessageLoaderParms parms("src.Server.cimserver.SERVER_NOT_STARTED", |
|
"cimserver not started: $0", e.getMessage()); |
|
Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE, |
|
MessageLoader::getMessage(parms)); |
|
cerr << MessageLoader::getMessage(parms) << endl; |
|
|
|
// |
|
// notify parent process (if there is a parent process) to terminate |
|
// |
|
if (daemonOption) |
|
_cimServerProcess->notify_parent(1); |
| |
|
deleteCIMServer(); |
|
return 1; |
|
} |
|
|
|
// Run the main CIM Server loop |
|
|
|
try |
|
{ |
#if defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM) | #if defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM) |
| |
// ARM is a z/OS internal restart facility. | // ARM is a z/OS internal restart facility. |
|
|
// | // |
// normal termination | // normal termination |
// | // |
|
|
#if defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM) | #if defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM) |
| |
// ARM is a z/OS internal restart facility. | // ARM is a z/OS internal restart facility. |
|
|
Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, | Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, |
Logger::INFORMATION, "src.Server.cimserver.STOPPED", | Logger::INFORMATION, "src.Server.cimserver.STOPPED", |
"$0 stopped.", _cimServerProcess->getProductName()); | "$0 stopped.", _cimServerProcess->getProductName()); |
|
|
#if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_OS_LINUX) \ |
|
|| defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM) || defined(PEGASUS_OS_AIX) \ |
|
|| defined(PEGASUS_OS_SOLARIS) || defined(PEGASUS_OS_VMS) |
|
// |
|
// Note: do not remove the PID file created at startup time, since |
|
// shutdown is not complete until the CIMServer destructor completes. |
|
// |
|
#endif |
|
} |
|
catch (BindFailedException& e) |
|
{ |
|
Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE, |
|
"src.Server.cimserver.SERVER_NOT_STARTED", |
|
"cimserver not started: $0", e.getMessage()); |
|
MessageLoaderParms parms("src.Server.cimserver.SERVER_NOT_STARTED", |
|
"cimserver not started: $0", e.getMessage()); |
|
|
|
cerr << MessageLoader::getMessage(parms) << endl; |
|
|
|
// |
|
// notify parent process (if there is a parent process) to terminate |
|
// |
|
if (daemonOption) |
|
_cimServerProcess->notify_parent(1); |
|
|
|
deleteCIMServer(); |
|
return 1; |
|
} | } |
catch (Exception& e) | catch (Exception& e) |
{ | { |
Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, Logger::WARNING, |
|
"src.Server.cimserver.ERROR", |
|
"Error: $0", |
|
e.getMessage()); |
|
MessageLoaderParms parms( | MessageLoaderParms parms( |
"src.Server.cimserver.ERROR", | "src.Server.cimserver.ERROR", |
"Error: $0", | "Error: $0", |
e.getMessage()); | e.getMessage()); |
PEGASUS_STD(cerr) << MessageLoader::getMessage(parms) << |
Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::WARNING, |
PEGASUS_STD(endl); |
MessageLoader::getMessage(parms)); |
|
cerr << MessageLoader::getMessage(parms) << endl; |
// |
|
// notify parent process (if there is a parent process) to terminate |
|
// |
|
if (daemonOption) |
|
_cimServerProcess->notify_parent(1); |
|
| |
deleteCIMServer(); | deleteCIMServer(); |
return 1; | return 1; |