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

Diff for /pegasus/src/Server/cimserver.cpp between version 1.36 and 1.46

version 1.36, 2001/12/20 21:33:04 version 1.46, 2002/05/13 21:47:11
Line 30 
Line 30 
 // //
 // Modified By: Jenny Yu (jenny_yu@hp.com) // Modified By: Jenny Yu (jenny_yu@hp.com)
 // //
   // Modified By: Sushma Fernandes (sushma_fernandes@hp.com)
   //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
  
Line 77 
Line 79 
 #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
  
Line 130 
Line 132 
  
 static const char OPTION_TIMEOUT     = 'T'; static const char OPTION_TIMEOUT     = 'T';
  
 static const String NAMESPACE = "root/cimv2";  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 = "operationTimeout"; 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.
 */ */
Line 176 
Line 148 
     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);
     }     }
Line 241 
Line 210 
  
     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;
Line 255 
Line 223 
     //     //
     // 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
Line 277 
Line 243 
     //     //
     try     try
     {     {
         client.connect(hostStr.allocateCString());          client.connectLocal();
     }     }
     catch(Exception& e)      catch(CIMClientException& e)
     {     {
         Logger::put(Logger::STANDARD_LOG, "CIMServer", Logger::INFORMATION,         Logger::put(Logger::STANDARD_LOG, "CIMServer", Logger::INFORMATION,
             "Failed to connect to $0 $1.", PEGASUS_NAME, e.getMessage());             "Failed to connect to $0 $1.", PEGASUS_NAME, e.getMessage());
  
         PEGASUS_STD(cerr) << "Failed to connect to server: " << e.getMessage() << PEGASUS_STD(endl);          PEGASUS_STD(cerr) << "Failed to connect to server: ";
         exit(1);          PEGASUS_STD(cerr) << e.getMessage() << PEGASUS_STD(endl);
           exit(0);
     }     }
  
     try     try
Line 304 
Line 271 
         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::UINT32),              CIMValue(Uint32(timeoutValue))));
             CIMValue(timeoutValue)));  
  
         CIMValue retValue = client.invokeMethod(         CIMValue retValue = client.invokeMethod(
             NAMESPACE,             NAMESPACE,
Line 333 
Line 289 
             "$0 terminated on port $1.", PEGASUS_NAME, portNumberStr);             "$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);
     }     }
  
Line 362 
Line 351 
     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 )
Line 403 
Line 404 
                     if (i + 1 < argc)                     if (i + 1 < argc)
                     {                     {
                         pegasusHome.assign(argv[i + 1]);                         pegasusHome.assign(argv[i + 1]);
                         SetEnvironmentVariables(argv[i + 1]);  
                     }                     }
                     else                     else
                     {                     {
Line 515 
Line 515 
         }         }
     }     }
  
     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.
Line 582 
Line 584 
  
         if (String::equal(configManager->getCurrentValue("logtrace"), "true"))         if (String::equal(configManager->getCurrentValue("logtrace"), "true"))
         {         {
             Handler::setMessageLogTrace(true);  
             pegasusIOLog = true;             pegasusIOLog = true;
         }         }
  
Line 592 
Line 593 
         // ATTN-KS: create String based directory functions.         // ATTN-KS: create String based directory functions.
  
         logsDirectory = configManager->getCurrentValue("logdir");         logsDirectory = configManager->getCurrentValue("logdir");
           logsDirectory =
               ConfigManager::getHomedPath(configManager->getCurrentValue("logdir"));
  
         // 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.
Line 621 
Line 624 
             }             }
  
             shutdownCIMOM(forceOption, timeoutValue);             shutdownCIMOM(forceOption, timeoutValue);
   
             cout << "Pegasus CIM Server terminated." << endl;             cout << "Pegasus CIM Server terminated." << endl;
             exit(0);             exit(0);
         }         }
Line 637 
Line 641 
  
         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;
         }         }
Line 698 
Line 701 
     // 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://");
Line 711 
Line 714 
 #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);
Line 725 
Line 732 
  
         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 )
Line 751 
Line 781 
           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)
     {     {

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