version 1.35, 2001/12/13 14:54:56
|
version 1.51, 2002/05/16 03:14:23
|
|
|
// | // |
// Modified By: Jenny Yu (jenny_yu@hp.com) | // Modified By: Jenny Yu (jenny_yu@hp.com) |
// | // |
|
// Modified By: Sushma Fernandes (sushma_fernandes@hp.com) |
|
// |
//%///////////////////////////////////////////////////////////////////////////// | //%///////////////////////////////////////////////////////////////////////////// |
| |
| |
|
|
| |
| |
#include <Pegasus/Common/Config.h> | #include <Pegasus/Common/Config.h> |
|
#include <Pegasus/suballoc/suballoc.h> |
#include <iostream> | #include <iostream> |
#include <cassert> | #include <cassert> |
#include <cstdlib> | #include <cstdlib> |
|
#include <fstream> |
#include <Pegasus/Common/FileSystem.h> | #include <Pegasus/Common/FileSystem.h> |
#include <Pegasus/Common/Monitor.h> | #include <Pegasus/Common/Monitor.h> |
#include <Pegasus/Server/CIMServer.h> | #include <Pegasus/Server/CIMServer.h> |
#include <Pegasus/Common/PegasusVersion.h> | #include <Pegasus/Common/PegasusVersion.h> |
#include <Pegasus/Protocol/Handler.h> |
|
#include <Pegasus/Common/Logger.h> | #include <Pegasus/Common/Logger.h> |
#include <Pegasus/Common/System.h> | #include <Pegasus/Common/System.h> |
#include <Pegasus/Common/Tracer.h> | #include <Pegasus/Common/Tracer.h> |
#include <Pegasus/Config/ConfigManager.h> | #include <Pegasus/Config/ConfigManager.h> |
#include <Pegasus/Client/CIMClient.h> | #include <Pegasus/Client/CIMClient.h> |
#include <Pegasus/Common/HTTPConnector.h> |
|
#include <Pegasus/Server/ShutdownService.h> | #include <Pegasus/Server/ShutdownService.h> |
#ifndef PEGASUS_OS_ZOS |
#include <Pegasus/Common/Destroyer.h> |
|
#if !defined(PEGASUS_OS_ZOS) && ! defined(PEGASUS_OS_HPUX) |
#include <slp/slp.h> | #include <slp/slp.h> |
#endif | #endif |
| |
|
|
| |
static const char OPTION_TIMEOUT = 'T'; | static const char OPTION_TIMEOUT = 'T'; |
| |
static const String NAMESPACE = "root/cimv2"; |
#if defined(PEGASUS_OS_HPUX) |
|
static const char OPTION_BINDVERBOSE = 'X'; |
|
#endif |
|
|
|
static const String NAMESPACE = "root/PG_Internal"; |
static const String CLASSNAME_SHUTDOWNSERVICE = "PG_ShutdownService"; | static const String CLASSNAME_SHUTDOWNSERVICE = "PG_ShutdownService"; |
static const String PROPERTY_TIMEOUT = "timeout"; |
static const String PROPERTY_TIMEOUT = "operationTimeout"; |
|
static const String CIMSERVERSTART_FILE = "/etc/wbem/cimserver_start.conf"; |
| |
ConfigManager* configManager; | ConfigManager* configManager; |
| |
void GetEnvironmentVariables( |
|
const char* arg0, |
|
String& pegasusHome) |
|
{ |
|
// Get environment variables: |
|
|
|
const char* tmp = getenv("PEGASUS_HOME"); |
|
|
|
if (!tmp) |
|
{ |
|
cerr << arg0 << ": PEGASUS_HOME environment variable undefined" << endl; |
|
exit(1); |
|
} |
|
|
|
pegasusHome = tmp; |
|
FileSystem::translateSlashes(pegasusHome); |
|
} |
|
|
|
void SetEnvironmentVariables( |
|
const char* arg0) |
|
{ |
|
cout << "PEGASUS_HOME is now " << arg0 << endl; |
|
|
|
String str = "PEGASUS_HOME="; |
|
str += arg0; |
|
char* tmp = str.allocateCString(); |
|
putenv(tmp); |
|
|
|
// Note: don't delete tmp! putenv() uses it. |
|
} |
|
|
|
/** 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. |
*/ | */ |
|
|
char** argv, | char** argv, |
const String& pegasusHome) | const String& pegasusHome) |
{ | { |
String currentFile = pegasusHome + "/" + CURRENT_CONFIG_FILE; |
|
String plannedFile = pegasusHome + "/" + PLANNED_CONFIG_FILE; |
|
|
|
try | try |
{ | { |
cm->mergeConfigFiles(currentFile, plannedFile); |
cm->mergeConfigFiles(); |
| |
cm->mergeCommandLine(argc, argv); | cm->mergeCommandLine(argc, argv); |
} | } |
|
|
| |
usage.append (" configProperty=value\n"); | usage.append (" configProperty=value\n"); |
usage.append (" port=nnnn - sets port number to listen on\n"); | usage.append (" port=nnnn - sets port number to listen on\n"); |
usage.append (" home=/pegasus/bin - sets pegasus home directory\n"); |
|
usage.append (" logdir=/pegasus/logs - directory for log files\n"); | usage.append (" logdir=/pegasus/logs - directory for log files\n"); |
| |
cout << endl; | cout << endl; |
|
|
cout << usage << endl; | cout << usage << endl; |
} | } |
| |
void shutdownCIMOM(Boolean forceOption, String timeoutStr) |
void shutdownCIMOM(Boolean forceOption, Uint32 timeoutValue) |
{ | { |
// | // |
// Create CIMClient object | // Create CIMClient object |
// | // |
Monitor* monitor = new Monitor; |
CIMClient client; |
HTTPConnector* httpConnector = new HTTPConnector(monitor); |
|
CIMClient client(monitor, httpConnector); |
|
| |
// | // |
// Get the port number | // Get the port number |
|
|
hostStr.append(":"); | hostStr.append(":"); |
hostStr.append(portNumberStr); | hostStr.append(portNumberStr); |
| |
|
// Put server shutdown message to the logger |
|
Logger::put(Logger::STANDARD_LOG, "CIMServer", Logger::INFORMATION, |
|
"Shutdown $0 on port $1.", PEGASUS_NAME, portNumberStr); |
|
|
// | // |
// open connection to CIMOM | // open connection to CIMOM |
// | // |
try | try |
{ | { |
client.connect(hostStr.allocateCString()); |
client.connectLocal(); |
} | } |
catch(Exception& e) |
catch(CIMClientException& e) |
{ | { |
PEGASUS_STD(cerr) << "Failed to connect to server: " << e.getMessage() << PEGASUS_STD(endl); |
Logger::put(Logger::STANDARD_LOG, "CIMServer", Logger::INFORMATION, |
exit(1); |
"Failed to connect to $0 $1.", PEGASUS_NAME, e.getMessage()); |
|
|
|
PEGASUS_STD(cerr) << "Failed to connect to server: "; |
|
PEGASUS_STD(cerr) << e.getMessage() << PEGASUS_STD(endl); |
|
exit(0); |
} | } |
| |
try | try |
{ | { |
// | // |
// construct CIMReference |
// construct CIMObjectPath |
// | // |
String referenceStr = "//"; | String referenceStr = "//"; |
referenceStr.append(hostStr); | referenceStr.append(hostStr); |
referenceStr.append("/root/cimv2:PG_ShutdownService"); | referenceStr.append("/root/cimv2:PG_ShutdownService"); |
CIMReference reference(referenceStr); |
CIMObjectPath reference(referenceStr); |
| |
// | // |
// issue the invokeMethod request on the shutdown method | // issue the invokeMethod request on the shutdown method |
|
|
Array<CIMParamValue> inParams; | Array<CIMParamValue> inParams; |
Array<CIMParamValue> outParams; | Array<CIMParamValue> outParams; |
| |
if (forceOption) |
inParams.append(CIMParamValue("force", |
{ |
CIMValue(Boolean(forceOption)))); |
inParams.append(CIMParamValue( |
|
CIMParameter("force", CIMType::STRING), |
|
CIMValue("TRUE"))); |
|
} |
|
else |
|
{ |
|
inParams.append(CIMParamValue( |
|
CIMParameter("force", CIMType::STRING), |
|
CIMValue("FALSE"))); |
|
} |
|
| |
inParams.append(CIMParamValue( |
inParams.append(CIMParamValue("timeout", |
CIMParameter("timeout", CIMType::STRING), |
CIMValue(Uint32(timeoutValue)))); |
CIMValue(timeoutStr))); |
|
| |
CIMValue retValue = client.invokeMethod( | CIMValue retValue = client.invokeMethod( |
NAMESPACE, | NAMESPACE, |
|
|
"shutdown", | "shutdown", |
inParams, | inParams, |
outParams); | outParams); |
|
|
|
// Put server shutdown message to the logger |
|
Logger::put(Logger::STANDARD_LOG, "CIMServer", Logger::INFORMATION, |
|
"$0 terminated on port $1.", PEGASUS_NAME, portNumberStr); |
|
|
|
} |
|
catch(CIMClientCIMException& e) |
|
{ |
|
PEGASUS_STD(cerr) << "Failed to shutdown server: "; |
|
PEGASUS_STD(cerr) << e.getMessage() << PEGASUS_STD(endl); |
|
exit(1); |
|
} |
|
catch(CIMClientException& e) |
|
{ |
|
// |
|
// This may mean the cimserver has been terminated and returns the |
|
// "Empty HTTP response message" HTTP error response. To be sure, |
|
// we need to check if cimserver is indeed terminated. |
|
// |
|
#ifdef PEGASUS_OS_TYPE_UNIX |
|
System::sleep(1); |
|
int ret = system("ps -ef | grep cimserver | grep -v grep | grep -v cimserverd >/dev/null"); |
|
if (ret == 0) |
|
{ |
|
// cimserver has been terminated |
|
// Put server shutdown message to the logger |
|
Logger::put(Logger::STANDARD_LOG, "CIMServer", Logger::INFORMATION, |
|
"$0 terminated on port $1.", PEGASUS_NAME, portNumberStr); |
|
} |
|
else |
|
{ |
|
// cimserver is still running |
|
PEGASUS_STD(cerr) << "Failed to shutdown server: "; |
|
PEGASUS_STD(cerr) << e.getMessage() << PEGASUS_STD(endl); |
|
exit(1); |
|
} |
|
#endif |
} | } |
catch(Exception& e) | catch(Exception& e) |
{ | { |
PEGASUS_STD(cerr) << "Failed to shutdown server: " << e.getMessage() << PEGASUS_STD(endl); |
PEGASUS_STD(cerr) << "Failed to shutdown server: "; |
|
PEGASUS_STD(cerr) << e.getMessage() << PEGASUS_STD(endl); |
exit(1); | exit(1); |
} | } |
| |
|
|
String timeoutStr = String::EMPTY; | String timeoutStr = String::EMPTY; |
long timeoutValue = 0; | long timeoutValue = 0; |
| |
|
|
|
// |
|
// Get environment variables: |
|
// |
|
const char* tmp = getenv("PEGASUS_HOME"); |
|
|
|
if (tmp) |
|
{ |
|
pegasusHome = tmp; |
|
} |
|
|
|
FileSystem::translateSlashes(pegasusHome); |
|
|
// on Windows NT if there are no command-line options, run as a service | // on Windows NT if there are no command-line options, run as a service |
| |
if (argc == 1 ) | if (argc == 1 ) |
|
|
if (i + 1 < argc) | if (i + 1 < argc) |
{ | { |
pegasusHome.assign(argv[i + 1]); | pegasusHome.assign(argv[i + 1]); |
SetEnvironmentVariables(argv[i + 1]); |
|
} | } |
else | else |
{ | { |
|
|
memmove(&argv[i], &argv[i + 2], (argc-i-1) * sizeof(char*)); | memmove(&argv[i], &argv[i + 2], (argc-i-1) * sizeof(char*)); |
argc -= 2; | argc -= 2; |
} | } |
|
#if defined(PEGASUS_OS_HPUX) |
|
// |
|
// Check to see if user asked for the version (-X option): |
|
// |
|
if (*option == OPTION_BINDVERBOSE) |
|
{ |
|
System::bindVerbose = true; |
|
cout << "Unsupported debug option, BIND_VERBOSE, enabled." |
|
<< endl; |
|
// remove the option from the command line |
|
memmove(&argv[i], &argv[i + 1], (argc-i) * sizeof(char*)); |
|
argc--; |
|
} |
|
#endif |
// | // |
// Check to see if user asked for shutdown (-s option): | // Check to see if user asked for shutdown (-s option): |
// | // |
|
|
} | } |
} | } |
| |
if (pegasusHome.size() == 0) |
// |
GetEnvironmentVariables(argv[0], pegasusHome); |
// Set the value for pegasusHome property |
|
// |
|
ConfigManager::setPegasusHome(pegasusHome); |
| |
// | // |
// Get an instance of the Config Manager. | // Get an instance of the Config Manager. |
|
|
} | } |
| |
// | // |
|
// Check the log trace options and set global variable |
|
// |
|
|
|
if (String::equal(configManager->getCurrentValue("logtrace"), "true")) |
|
{ |
|
pegasusIOLog = true; |
|
} |
|
|
|
// Get the log file directory definition. |
|
// We put String into Cstring because |
|
// Directory functions only handle Cstring. |
|
// ATTN-KS: create String based directory functions. |
|
|
|
logsDirectory = configManager->getCurrentValue("logdir"); |
|
logsDirectory = |
|
ConfigManager::getHomedPath(configManager->getCurrentValue("logdir")); |
|
|
|
// Set up the Logger. This does not open the logs |
|
// Might be more logical to clean before set. |
|
// ATTN: Need tool to completely disable logging. |
|
|
|
Logger::setHomeDirectory(logsDirectory); |
|
|
|
// |
// Check to see if we need to shutdown CIMOM | // Check to see if we need to shutdown CIMOM |
// | // |
if (shutdownOption) | if (shutdownOption) |
|
|
} | } |
} | } |
| |
shutdownCIMOM(forceOption, timeoutStr); |
shutdownCIMOM(forceOption, timeoutValue); |
|
|
cout << "Pegasus CIM Server terminated." << endl; | cout << "Pegasus CIM Server terminated." << endl; |
exit(0); | exit(0); |
} | } |
|
|
| |
if (String::equal(configManager->getCurrentValue("trace"), "true")) | if (String::equal(configManager->getCurrentValue("trace"), "true")) |
{ | { |
Handler::setMessageTrace(true); |
|
pegasusIOTrace = true; | pegasusIOTrace = true; |
cout << "Trace Set" << endl; | cout << "Trace Set" << endl; |
} | } |
// |
|
// Check the log trace options and set global variable |
|
// |
|
|
|
if (String::equal(configManager->getCurrentValue("logtrace"), "true")) |
|
{ |
|
Handler::setMessageLogTrace(true); |
|
pegasusIOLog = true; |
|
} |
|
|
|
// Get the log file directory definition. |
|
// We put String into Cstring because |
|
// Directory functions only handle Cstring. |
|
// ATTN-KS: create String based directory functions. |
|
|
|
logsDirectory = configManager->getCurrentValue("logdir"); |
|
| |
// Set up the Logger. This does not open the logs |
// Leave this in until people get familiar with the logs. |
// Might be more logical to clean before set. |
cout << "Logs Directory = " << logsDirectory << endl; |
// ATTN: Need tool to completely disable logging. |
|
|
|
Logger::setHomeDirectory(logsDirectory); |
|
| |
if (String::equal(configManager->getCurrentValue("cleanlogs"), "true")) | if (String::equal(configManager->getCurrentValue("cleanlogs"), "true")) |
{ | { |
Logger::clean(logsDirectory);; | Logger::clean(logsDirectory);; |
} | } |
| |
// Leave this in until people get familiar with the logs. |
|
cout << "Logs Directory = " << logsDirectory << endl; |
|
|
|
if (String::equal(configManager->getCurrentValue("slp"), "true")) | if (String::equal(configManager->getCurrentValue("slp"), "true")) |
{ | { |
useSLP = true; | useSLP = true; |
|
|
<< (useSSL ? " Use SSL " : " No SSL ") | << (useSSL ? " Use SSL " : " No SSL ") |
<< endl; | << endl; |
| |
|
// do we need to run as a daemon ? |
|
if (daemonOption) |
|
{ |
|
if(-1 == cimserver_fork()) |
|
exit(-1); |
|
} |
|
|
// Put server start message to the logger | // Put server start message to the logger |
Logger::put(Logger::STANDARD_LOG, "CIMServer", Logger::INFORMATION, | Logger::put(Logger::STANDARD_LOG, "CIMServer", Logger::INFORMATION, |
"Start $0 $1 port $2 $3 $4 $5", | "Start $0 $1 port $2 $3 $4 $5", |
|
|
(useSLP ? " SLP on " : " SLP off "), | (useSLP ? " SLP on " : " SLP off "), |
(useSSL ? " Use SSL " : " No SSL ")); | (useSSL ? " Use SSL " : " No SSL ")); |
| |
// do we need to run as a daemon ? |
|
if (daemonOption) |
|
{ |
|
if(-1 == cimserver_fork()) |
|
exit(-1); |
|
} |
|
|
|
// try loop to bind the address, and run the server | // try loop to bind the address, and run the server |
try | try |
{ | { |
#ifndef PEGASUS_OS_ZOS |
#if !defined(PEGASUS_OS_ZOS) && ! defined(PEGASUS_OS_HPUX) |
slp_client *discovery = new slp_client() ;; | slp_client *discovery = new slp_client() ;; |
String serviceURL; | String serviceURL; |
serviceURL.assign("service:cim.pegasus://"); | serviceURL.assign("service:cim.pegasus://"); |
|
|
#endif | #endif |
| |
Monitor monitor; | Monitor monitor; |
CIMServer server(&monitor, pegasusHome, useSSL); |
CIMServer server(&monitor, useSSL); |
| |
// bind throws an exception of the bind fails |
// bind throws an exception if the bind fails |
|
#ifdef PEGASUS_LOCAL_DOMAIN_SOCKET |
|
cout << "Binding to domain socket" << endl; |
|
#else |
cout << "Binding to " << address << endl; | cout << "Binding to " << address << endl; |
|
#endif |
| |
char* end = 0; | char* end = 0; |
long portNumber = strtol(address, &end, 10); | long portNumber = strtol(address, &end, 10); |
|
|
| |
time_t last = 0; | time_t last = 0; |
| |
|
#if defined(PEGASUS_OS_HPUX) |
|
// |
|
// create a file to indicate that the cimserver has started |
|
// |
|
fstream fs; |
|
ArrayDestroyer<char> p(CIMSERVERSTART_FILE.allocateCString()); |
|
fs.open(p.getPointer(), ios::in | ios::out); |
|
if (!fs) |
|
{ |
|
// |
|
// failed to create the file, write an entry to the log file |
|
// and proceed |
|
// |
|
Logger::put(Logger::STANDARD_LOG, "CIMServer", Logger::INFORMATION, |
|
"Failed to open the $0 file needed by cimserverd.", |
|
CIMSERVERSTART_FILE); |
|
} |
|
else |
|
{ |
|
fs.close(); |
|
} |
|
#endif |
|
|
// | // |
// Loop to call CIMServer's runForever() method until CIMServer | // Loop to call CIMServer's runForever() method until CIMServer |
// has been shutdown | // has been shutdown |
// | // |
while( !server.terminated() ) | while( !server.terminated() ) |
{ | { |
#ifndef PEGASUS_OS_ZOS |
#if !defined(PEGASUS_OS_ZOS) && ! defined(PEGASUS_OS_HPUX) |
if(useSLP ) | if(useSLP ) |
{ | { |
if( (time(NULL) - last ) > 60 ) | if( (time(NULL) - last ) > 60 ) |
|
|
server.runForever(); | server.runForever(); |
} | } |
| |
// This statement is unrechable! |
|
// | // |
// Logger::put(Logger::STANDARD_LOG, "CIMServer", Logger::INFORMATION, |
// normal termination |
// "Normal Termination"); |
// |
|
Logger::put(Logger::STANDARD_LOG, "CIMServer", Logger::INFORMATION, |
|
"Normal Termination"); |
|
|
|
#if defined(PEGASUS_OS_HPUX) |
|
// |
|
// close the file at startup time to indicate that the cimserver |
|
// has terminated normally. |
|
// |
|
FileSystem::removeFile(CIMSERVERSTART_FILE); |
|
#endif |
} | } |
catch(Exception& e) | catch(Exception& e) |
{ | { |