(file) Return to cimserver.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / WMIMapper / WMIServer

Diff for /pegasus/src/WMIMapper/WMIServer/cimserver.cpp between version 1.27.18.2 and 1.30

version 1.27.18.2, 2007/07/03 21:50:09 version 1.30, 2007/05/08 18:30:53
Line 76 
Line 76 
 // Alternatively, you can use the windows service manager. Pegasus shows up // Alternatively, you can use the windows service manager. Pegasus shows up
 // in the service database as "Pegasus CIM Object Manager" // in the service database as "Pegasus CIM Object Manager"
 // //
 // Mike Day, mdday@us.ibm.com  
 //  
 ////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////
  
  
Line 85 
Line 83 
 #include <Pegasus/Common/Constants.h> #include <Pegasus/Common/Constants.h>
 #include <iostream> #include <iostream>
 #include <Pegasus/Common/PegasusAssert.h> #include <Pegasus/Common/PegasusAssert.h>
 #include <cstdlib>  
 #include <fstream> #include <fstream>
 #include <Pegasus/Common/FileSystem.h> #include <Pegasus/Common/FileSystem.h>
 #include <Pegasus/Common/Monitor.h> #include <Pegasus/Common/Monitor.h>
Line 96 
Line 93 
 #include <Pegasus/Common/LanguageParser.h> #include <Pegasus/Common/LanguageParser.h>
 #include <Pegasus/Config/ConfigManager.h> #include <Pegasus/Config/ConfigManager.h>
 #include <Pegasus/Client/CIMClient.h> #include <Pegasus/Client/CIMClient.h>
 #include <Pegasus/Server/ShutdownService.h>  
 #include <Pegasus/Server/CIMServer.h> #include <Pegasus/Server/CIMServer.h>
 #include <Service/ServerProcess.h> #include <Service/ServerProcess.h>
   #include <Service/ServerShutdownClient.h>
   #include <Service/ServerRunStatus.h>
  
 #if defined(PEGASUS_OS_OS400) #if defined(PEGASUS_OS_OS400)
 #  include "vfyptrs.cinc" #  include "vfyptrs.cinc"
Line 108 
Line 106 
 PEGASUS_USING_PEGASUS; PEGASUS_USING_PEGASUS;
 PEGASUS_USING_STD; PEGASUS_USING_STD;
  
 #define PEGASUS_PROCESS_NAME "WMI Mapper";  #define PEGASUS_PROCESS_NAME "WMI Mapper"
  
 //Windows service variables are not defined elsewhere in the product //Windows service variables are not defined elsewhere in the product
 //enable ability to override these //enable ability to override these
Line 165 
Line 163 
         return PEGASUS_CIMSERVER_START_FILE;         return PEGASUS_CIMSERVER_START_FILE;
     }     }
  
     int cimserver_run(      int cimserver_run(int argc, char** argv, bool shutdownOption);
         int argc,  
         char** argv,  
         Boolean shutdownOption,  
         Boolean debugOutputOption);  
  
     void cimserver_stop(void);     void cimserver_stop(void);
 }; };
  
   ServerRunStatus _serverRunStatus(
       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 Monitor* _monitor = 0;
Line 213 
Line 209 
  
 /** 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.
   
       Some possible exceptions:  NoSuchFile, FileNotReadable, CannotRenameFile,
       ConfigFileSyntaxError, UnrecognizedConfigProperty, InvalidPropertyValue,
       CannotOpenFile.
 */ */
 void GetOptions( void GetOptions(
     ConfigManager* cm,     ConfigManager* cm,
     int& argc,     int& argc,
     char** argv)     char** argv)
 { {
     try  
     {  
         cm->mergeConfigFiles();         cm->mergeConfigFiles();
   
         cm->mergeCommandLine(argc, argv);         cm->mergeCommandLine(argc, argv);
     }     }
     catch (NoSuchFile&)  
     {  
         throw;  
     }  
     catch (FileNotReadable&)  
     {  
         throw;  
     }  
     catch (CannotRenameFile&)  
     {  
         throw;  
     }  
     catch (ConfigFileSyntaxError&)  
     {  
         throw;  
     }  
     catch(UnrecognizedConfigProperty&)  
     {  
         throw;  
     }  
     catch(InvalidPropertyValue&)  
     {  
         throw;  
     }  
     catch (CannotOpenFile&)  
     {  
         throw;  
     }  
 }  
  
 /* PrintHelp - This is temporary until we expand the options manager to allow /* PrintHelp - This is temporary until we expand the options manager to allow
    options help to be defined with the OptionRow entries and presented from    options help to be defined with the OptionRow entries and presented from
Line 330 
Line 298 
    return((ThreadReturnType)0);    return((ThreadReturnType)0);
 } }
  
 void shutdownCIMOM(Uint32 timeoutValue)  
 {  
     //  
     // Create CIMClient object  
     //  
     CIMClient client;  
   
     //  
     // Get local host name  
     //  
     String hostStr = System::getHostName();  
   
     //  
     // open connection to CIMOM  
     //  
     try  
     {  
         client.connectLocal();  
   
         //  
         // set client timeout to 2 seconds  
         //  
         client.setTimeout(2000);  
     }  
     catch(Exception&)  
     {  
 #ifdef PEGASUS_OS_OS400  
     //l10n  
     //Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,  
             //"Unable to connect to CIM Server.  CIM Server may not be running." );  
     Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,  
             "src.Server.cimserver.UNABLE_CONNECT_SERVER_MAY_NOT_BE_RUNNING",  
             "Unable to connect to CIM Server.  CIM Server may not be running." );  
     // The server job may still be active but not responding.  
     // Kill the job if it exists.  
     if(_cimServerProcess->cimserver_kill(0) == -1)  
        _cimServerProcess->cimserver_exitRC(2);  
     _cimServerProcess->cimserver_exitRC(1);  
 #else  
         //l10n  
         //PEGASUS_STD(cerr) << "Unable to connect to CIM Server." << PEGASUS_STD(endl);  
         //PEGASUS_STD(cerr) << "CIM Server may not be running." << PEGASUS_STD(endl);  
         MessageLoaderParms parms("src.Server.cimserver.UNABLE_CONNECT_SERVER_MAY_NOT_BE_RUNNING",  
                                                          "Unable to connect to CIM Server.\nCIM Server may not be running.\n");  
         PEGASUS_STD(cerr) << MessageLoader::getMessage(parms);  
         exit(1);  
 #endif  
     }  
   
     try  
     {  
         //  
         // construct CIMObjectPath  
         //  
         String referenceStr = "//";  
         referenceStr.append(hostStr);  
         referenceStr.append("/");  
         referenceStr.append(PEGASUS_NAMESPACENAME_SHUTDOWN.getString());  
         referenceStr.append(":");  
         referenceStr.append(PEGASUS_CLASSNAME_SHUTDOWN.getString());  
         CIMObjectPath reference(referenceStr);  
   
         //  
         // issue the invokeMethod request on the shutdown method  
         //  
         Array<CIMParamValue> inParams;  
         Array<CIMParamValue> outParams;  
   
         // set force option to true for now  
         inParams.append(CIMParamValue("force",  
             CIMValue(Boolean(true))));  
   
         inParams.append(CIMParamValue("timeout",  
             CIMValue(Uint32(timeoutValue))));  
   
         CIMValue retValue = client.invokeMethod(  
             PEGASUS_NAMESPACENAME_SHUTDOWN,  
             reference,  
             "shutdown",  
             inParams,  
             outParams);  
     }  
     catch(CIMException& e)  
     {  
 #ifdef PEGASUS_OS_OS400  
   
     if (e.getCode() == CIM_ERR_INVALID_NAMESPACE)  
     {  
         //l10n  
         //Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,  
             //"Failed to shutdown server: $0", "The repository may be empty.");  
         Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,  
             "src.Server.cimserver.SHUTDOWN_FAILED_REPOSITORY_EMPTY",  
             "Error in server shutdown: The repository may be empty.");  
     }  
     else  
     {  
         //l10n  
         //Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,  
             //"Failed to shutdown server: $0", e.getMessage());  
         Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,  
             "src.Server.cimserver.SHUTDOWN_FAILED",  
             "Error in server shutdown: $0", e.getMessage());  
     }  
     // Kill the server job.  
     if(_cimServerProcess->cimserver_kill(0) == -1)  
        _cimServerProcess->cimserver_exitRC(2);  
 #else  
         //l10n - TODO  
         MessageLoaderParms parms("src.Server.cimserver.SHUTDOWN_FAILED",  
                                  "Error in server shutdown: ");  
         PEGASUS_STD(cerr) << MessageLoader::getMessage(parms);  
         if (e.getCode() == CIM_ERR_INVALID_NAMESPACE)  
         {  
             //  
             // Repository may be empty.  
             //  
             //l10n - TODO  
             Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,  
                 "src.Server.cimserver.SHUTDOWN_FAILED_REPOSITORY_EMPTY",  
                 "Error in server shutdown: The repository may be empty.");  
             MessageLoaderParms parms("src.Server.cimserver.REPOSITORY_EMPTY",  
                                      "The repository may be empty.");  
             PEGASUS_STD(cerr) << MessageLoader::getMessage(parms) << PEGASUS_STD(endl);  
         }  
         else  
         {  
             //l10n - TODO  
             Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,  
                 "src.Server.cimserver.SHUTDOWN_FAILED",  
                 "Error in server shutdown: $0", e.getMessage());  
             PEGASUS_STD(cerr) << e.getMessage() << PEGASUS_STD(endl);  
         }  
   
     // Kill the cimserver process  
     if (_cimServerProcess->cimserver_kill(0) == 0)  
         {  
             //l10n - TODO  
             Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,  
                 "src.Server.cimserver.SERVER_FORCED_SHUTDOWN",  
             "Forced shutdown initiated.");  
             MessageLoaderParms parms("src.Server.cimserver.SERVER_FORCED_SHUTDOWN",  
                                      "Forced shutdown initiated.");  
             PEGASUS_STD(cerr) << MessageLoader::getMessage(parms) << PEGASUS_STD(endl);  
         }  
         exit(1);  
 #endif  
     }  
     catch(Exception&)  
     {  
         //  
         // This may mean that the CIM Server has terminated, causing this  
         // client to get a "Empty HTTP response message" exception.  It may  
         // also mean that the CIM Server is taking longer than 2 seconds  
         // (client timeout value) to terminate, causing this client to  
         // timeout with a "connection timeout" exception.  
         //  
         // Check to see if CIM Server is still running.  If CIM Server  
         // is still running and the shutdown timeout has not expired,  
         // loop and wait one second until either the CIM Server is  
         // terminated or timeout expires.  If timeout expires and  
         // the CIM Server is still running, kill the CIMServer process.  
         //  
         Uint32 maxWaitTime = timeoutValue - 2;  
         Boolean running = _cimServerProcess->isCIMServerRunning();  
         while ( running && maxWaitTime > 0 )  
         {  
             System::sleep(1);  
             running = _cimServerProcess->isCIMServerRunning();  
             maxWaitTime = maxWaitTime - 1;  
         }  
   
         if (running)  
         {  
        int kill_rc = _cimServerProcess->cimserver_kill(0);  
   
 #ifdef PEGASUS_OS_OS400  
         if(kill_rc == -1)  
         _cimServerProcess->cimserver_exitRC(2);  
         _cimServerProcess->cimserver_exitRC(1);  
 #endif  
   
 #if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) \  
 || defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM) || defined(PEGASUS_OS_SOLARIS) \  
 || defined (PEGASUS_OS_VMS)  
         if (kill_rc != -1)  
             {  
                 //l10n - TODO  
                 Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,  
                     "src.Server.cimserver.TIMEOUT_EXPIRED_SERVER_KILLED",  
                     "Shutdown timeout expired.  Forced shutdown initiated.");  
                 MessageLoaderParms parms("src.Server.cimserver.TIMEOUT_EXPIRED_SERVER_KILLED",  
                     "Shutdown timeout expired.  Forced shutdown initiated.");  
                 cout << MessageLoader::getMessage(parms) << endl;  
                 exit(0);  
             }  
 #endif  
         }  
     }  
   
     return;  
 }  
   
  
 ///////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////
 //  MAIN //  MAIN
 ////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
 int main(int argc, char** argv) int main(int argc, char** argv)
 { {
     String pegasusHome  = String::EMPTY;      String pegasusHome;
     Boolean shutdownOption = false;     Boolean shutdownOption = false;
     Boolean debugOutputOption = false;  
  
 //l10n //l10n
 // Set Message loading to process locale // Set Message loading to process locale
Line 736 
Line 500 
     // Do the plaform specific run     // Do the plaform specific run
     //     //
  
     return _cimServerProcess->platform_run(      return _cimServerProcess->platform_run( argc, argv, shutdownOption );
         argc, argv, shutdownOption, debugOutputOption);  
 } }
  
 void CIMServerProcess::cimserver_stop() void CIMServerProcess::cimserver_stop()
Line 758 
Line 521 
 // specific runs may need to deal with bettter (instead of exit(), etc). // specific runs may need to deal with bettter (instead of exit(), etc).
 // //
  
 int CIMServerProcess::cimserver_run(  int CIMServerProcess::cimserver_run( int argc, char** argv, Boolean shutdownOption )
     int argc,  
     char** argv,  
     Boolean shutdownOption,  
     Boolean debugOutputOption)  
 { {
     String logsDirectory = String::EMPTY;      String logsDirectory;
     Boolean daemonOption = false;     Boolean daemonOption = false;
  
     //     //
Line 889 
Line 648 
     if (os400StartupOption == false)     if (os400StartupOption == false)
     {     {
 #endif #endif
         // 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 =         logsDirectory =
         ConfigManager::getHomedPath(configManager->getCurrentValue("logdir"));         ConfigManager::getHomedPath(configManager->getCurrentValue("logdir"));
 #ifdef PEGASUS_OS_OS400 #ifdef PEGASUS_OS_OS400
Line 919 
Line 672 
                 configManager->getCurrentValue("shutdownTimeout");                 configManager->getCurrentValue("shutdownTimeout");
             Uint32 timeoutValue = strtol(configTimeout.getCString(), (char **)0, 10);             Uint32 timeoutValue = strtol(configTimeout.getCString(), (char **)0, 10);
  
             shutdownCIMOM(timeoutValue);              ServerShutdownClient serverShutdownClient(&_serverRunStatus);
               serverShutdownClient.shutdown(timeoutValue);
  
 #ifdef PEGASUS_OS_OS400 #ifdef PEGASUS_OS_OS400
         //l10n  
         //Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::INFORMATION,  
             //"CIM Server stopped.");  
         Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::INFORMATION,         Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::INFORMATION,
             "src.Server.cimserver.SERVER_STOPPED",             "src.Server.cimserver.SERVER_STOPPED",
             "CIM Server stopped.");             "CIM Server stopped.");
             cimserver_exitRC(0);             cimserver_exitRC(0);
 #else #else
             //l10n              MessageLoaderParms parms(
             //cout << "CIM Server stopped." << endl;                  "src.Server.cimserver.SERVER_STOPPED",
             MessageLoaderParms parms("src.Server.cimserver.SERVER_STOPPED",  
                                      "CIM Server stopped.");                                      "CIM Server stopped.");
  
             cout << MessageLoader::getMessage(parms) << endl;             cout << MessageLoader::getMessage(parms) << endl;
Line 940 
Line 690 
 #endif #endif
         }         }
  
 #if defined(PEGASUS_DEBUG)  #if defined(PEGASUS_DEBUG) && !defined(PEGASUS_USE_SYSLOGS)
         // Leave this in until people get familiar with the logs.         // Leave this in until people get familiar with the logs.
         //l10n  
         //cout << "Logs Directory = " << logsDirectory << endl;  
         MessageLoaderParms parms("src.Server.cimserver.LOGS_DIRECTORY",         MessageLoaderParms parms("src.Server.cimserver.LOGS_DIRECTORY",
                                  "Logs Directory = ");                                  "Logs Directory = ");
         cout << MessageLoader::getMessage(parms) << logsDirectory << endl;         cout << MessageLoader::getMessage(parms) << logsDirectory << endl;
Line 1052 
Line 800 
 //l10n //l10n
  
     // Get the parent's PID before forking     // Get the parent's PID before forking
     _cimServerProcess->set_parent_pid(System::getPID());      _serverRunStatus.setParentPid(System::getPID());
  
     // do we need to run as a daemon ?     // do we need to run as a daemon ?
     if (daemonOption)     if (daemonOption)
Line 1124 
Line 872 
     // if CIMServer is already running, print message and     // if CIMServer is already running, print message and
     // notify parent process (if there is a parent process) to terminate     // notify parent process (if there is a parent process) to terminate
     //     //
     if(_cimServerProcess->isCIMServerRunning())      if (_serverRunStatus.isServerRunning())
     {     {
     //l10n          MessageLoaderParms parms(
         //cout << "Unable to start CIMServer." << endl;              "src.Server.cimserver.UNABLE_TO_START_SERVER_ALREADY_RUNNING",
         //cout << "CIMServer is already running." << endl;  
         MessageLoaderParms parms("src.Server.cimserver.UNABLE_TO_START_SERVER_ALREADY_RUNNING",  
                      "Unable to start CIMServer.\nCIMServer is already running.");                      "Unable to start CIMServer.\nCIMServer is already running.");
     PEGASUS_STD(cerr) << MessageLoader::getMessage(parms) << PEGASUS_STD(endl);          PEGASUS_STD(cerr) << MessageLoader::getMessage(parms) <<
               PEGASUS_STD(endl);
  
     //     //
         // notify parent process (if there is a parent process) to terminate         // 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;
     }     }
  
 #endif #endif
Line 1147 
Line 896 
     // try loop to bind the address, and run the server     // try loop to bind the address, and run the server
     try     try
     {     {
   
     _monitor  = new Monitor();     _monitor  = new Monitor();
     //PEP#222  
     //CIMServer server(&monitor);  
     //CimserverHolder cimserverHolder( &server );  
     _cimServer = new CIMServer(_monitor);     _cimServer = new CIMServer(_monitor);
  
  
         if (enableHttpConnection)         if (enableHttpConnection)
         {         {
 #ifdef PEGASUS_ENABLE_IPV6              _cimServer->addAcceptor(false, portNumberHttp, false, false);
             _cimServer->addAcceptor(HTTPAcceptor::IPV6_CONNECTION,  
                 portNumberHttp, false);  
 #endif  
   
 #if !defined (PEGASUS_ENABLE_IPV6) || defined (PEGASUS_OS_TYPE_WINDOWS)  
             _cimServer->addAcceptor(HTTPAcceptor::IPV4_CONNECTION,  
                 portNumberHttp, false);  
 #endif  
   
             //l10n  
             //Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,  
                         //"Listening on HTTP port $0.", portNumberHttp);  
  
             Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,              Logger::put_l(
                   Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,
                             "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);
         }         }
   
         if (enableHttpsConnection)         if (enableHttpsConnection)
         {         {
 #ifdef PEGASUS_ENABLE_IPV6              _cimServer->addAcceptor(false, portNumberHttps, true, false);
             _cimServer->addAcceptor(HTTPAcceptor::IPV6_CONNECTION,  
                 portNumberHttps, true);  
 #endif  
   
 #if !defined (PEGASUS_ENABLE_IPV6) || defined (PEGASUS_OS_TYPE_WINDOWS)  
             _cimServer->addAcceptor(HTTPAcceptor::IPV4_CONNECTION,  
                 portNumberHttps, true);  
 #endif  
  
             //l10n              Logger::put_l(
             //Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,                  Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,
                         //"Listening on HTTPS port $0.", portNumberHttps);  
             Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,  
                             "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);
         }         }
  
 #ifndef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET #ifndef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET
         _cimServer->addAcceptor(HTTPAcceptor::LOCAL_CONNECTION, 0, false);          _cimServer->addAcceptor(true, 0, false, false);
         //l10n          Logger::put_l(
         //Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,              Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,
                     //"Listening on local connection socket.");  
         Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,  
               "src.Server.cimserver.LISTENING_ON_LOCAL",               "src.Server.cimserver.LISTENING_ON_LOCAL",
               "Listening on local connection socket.");               "Listening on local connection socket.");
 #endif #endif
Line 1208 
Line 931 
 #if defined(PEGASUS_DEBUG) #if defined(PEGASUS_DEBUG)
         if (enableHttpConnection)         if (enableHttpConnection)
         {         {
             //l10n              MessageLoaderParms parms(
             //cout << "Listening on HTTP port " << portNumberHttp << endl;                  "src.Server.cimserver.LISTENING_ON_HTTP_PORT",
       MessageLoaderParms parms("src.Server.cimserver.LISTENING_ON_HTTP_PORT",  
                    "Listening on HTTP port $0.", portNumberHttp);                    "Listening on HTTP port $0.", portNumberHttp);
             cout << MessageLoader::getMessage(parms) << endl;             cout << MessageLoader::getMessage(parms) << endl;
         }         }
         if (enableHttpsConnection)         if (enableHttpsConnection)
         {         {
             //l10n              MessageLoaderParms parms(
             //cout << "Listening on HTTPS port " << portNumberHttps << endl;                  "src.Server.cimserver.LISTENING_ON_HTTPS_PORT",
             MessageLoaderParms parms("src.Server.cimserver.LISTENING_ON_HTTPS_PORT",  
                      "Listening on HTTPS port $0.", portNumberHttps);                      "Listening on HTTPS port $0.", portNumberHttps);
             cout << MessageLoader::getMessage(parms) << endl;             cout << MessageLoader::getMessage(parms) << endl;
         }         }
  
 # ifndef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET # ifndef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET
         //l10n          MessageLoaderParms parms(
         //cout << "Listening on local connection socket" << endl;              "src.Server.cimserver.LISTENING_ON_LOCAL",
         MessageLoaderParms parms("src.Server.cimserver.LISTENING_ON_LOCAL",  
                  "Listening on local connection socket.");                  "Listening on local connection socket.");
         cout << MessageLoader::getMessage(parms) << endl;         cout << MessageLoader::getMessage(parms) << endl;
 # endif # endif
Line 1235 
Line 955 
         // bind throws an exception if the bind fails         // bind throws an exception if the bind fails
         try {         try {
            _cimServer->bind();            _cimServer->bind();
         } catch (const BindFailedException &e)          }
           catch (const BindFailedException &e)
         {         {
 #ifdef PEGASUS_DEBUG #ifdef PEGASUS_DEBUG
         MessageLoaderParms parms("src.Server.cimserver.BIND_FAILED",         MessageLoaderParms parms("src.Server.cimserver.BIND_FAILED",
Line 1252 
Line 973 
     // notify parent process (if there is a parent process) to terminate     // notify parent process (if there is a parent process) to terminate
         // so user knows that there is cimserver ready to serve CIM requests.         // so user knows that there is cimserver ready to serve CIM requests.
     if (daemonOption)     if (daemonOption)
           {
         _cimServerProcess->notify_parent(0);         _cimServerProcess->notify_parent(0);
           }
  
     time_t last = 0;  #if defined(PEGASUS_OS_HPUX) || \
       defined(PEGASUS_OS_LINUX) || \
 #if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_OS_LINUX) || defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM) \      defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM) || \
     || defined(PEGASUS_OS_AIX) || defined(PEGASUS_OS_SOLARIS) \      defined(PEGASUS_OS_AIX) || \
     || defined(PEGASUS_OS_VMS)      defined(PEGASUS_OS_SOLARIS) || \
       defined(PEGASUS_OS_VMS)
         //         //
         // create a file to indicate that the cimserver has started and         // create a file to indicate that the cimserver has started and
         // save the process id of the cimserver process in the file         // save the process id of the cimserver process in the file
         //         //
         // remove the old file if it exists          _serverRunStatus.setServerRunning();
         System::removeFile(_cimServerProcess->getPIDFileName());  
   
         // open the file  
         FILE *pid_file = fopen(_cimServerProcess->getPIDFileName(), "w");  
   
         if (pid_file)  
         {  
             // save the pid in the file  
             fprintf(pid_file, "%ld\n", _cimServerProcess->get_server_pid());  
             fclose(pid_file);  
         }  
 #endif #endif
  
 #if defined(PEGASUS_DEBUG) #if defined(PEGASUS_DEBUG)
Line 1351 
Line 1064 
     return 0;     return 0;
 } }
  
   
   
   

Legend:
Removed from v.1.27.18.2  
changed lines
  Added in v.1.30
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2