(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.34 and 1.34.2.1

version 1.34, 2001/07/17 00:49:05 version 1.34.2.1, 2001/07/31 23:54:39
Line 26 
Line 26 
 // //
 // Modified By: Karl Schopmeyer (k.schopmeyer@opengroup.org) // Modified By: Karl Schopmeyer (k.schopmeyer@opengroup.org)
 // //
   // Modified By: Nag Boranna (nagaraja_boranna@hp.com)
   //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
  
Line 69 
Line 71 
 #include <cstdlib> #include <cstdlib>
 #include <Pegasus/Common/FileSystem.h> #include <Pegasus/Common/FileSystem.h>
 #include <Pegasus/Common/Selector.h> #include <Pegasus/Common/Selector.h>
 #include <Pegasus/Common/OptionManager.h>  //#include <Pegasus/Common/OptionManager.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/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/Config/ConfigManager.h>
 #include <slp/slp.h> #include <slp/slp.h>
  
  
Line 90 
Line 94 
 PEGASUS_USING_PEGASUS; PEGASUS_USING_PEGASUS;
 PEGASUS_USING_STD; PEGASUS_USING_STD;
  
   /**
       The command name.
   */
   static const char COMMAND_NAME []    = "cimserver";
   
   /**
       The constant defining usage string.
   */
   static const char USAGE []           = "Usage: ";
   
   
 void GetEnvironmentVariables( void GetEnvironmentVariables(
     const char* arg0,     const char* arg0,
     String& pegasusHome)     String& pegasusHome)
Line 109 
Line 124 
 } }
  
 /** 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 option manager.      and sets up the options from that table using the config manager.
 */ */
 void GetOptions( void GetOptions(
     OptionManager& om,      ConfigManager* cm,
     int& argc,     int& argc,
     char** argv,     char** argv,
     const String& pegasusHome)     const String& pegasusHome)
 { {
     static struct OptionRow optionsTable[] =      String currentFile = pegasusHome + "/" + CURRENT_CONFIG_FILE;
       String plannedFile = pegasusHome + "/" + PLANNED_CONFIG_FILE;
   
       try
     {     {
         {"home", "/etc/pegasus", false, Option::STRING, 0, 0, "D",          cm->mergeConfigFiles(currentFile, plannedFile);
                     "Sets the pegasus home directory"},  
         {"port", "5988", false, Option::WHOLE_NUMBER, 0, 0, "port",  
                         "specifies port number to listen on" },  
         {"trace", "false", false, Option::BOOLEAN, 0, 0, "t",  
                         "turns on trace of Client IO to console "},  
         {"logtrace", "false", false, Option::BOOLEAN, 0, 0, "l",  
                         "Turns on trace of Client IO to trace log "},  
         {"options", "false", false, Option::BOOLEAN, 0, 0, "options",  
                         " Displays the settings of the Options "},  
         {"severity", "ALL", false, Option::STRING, 0, 0, "s",  
   
                     "Sets the severity level that will be logged "},  
         {"logs", "ALL", false, Option::STRING, 0, 0, "X",  
                         "Not Used "},  
         {"daemon", "false", false, Option::BOOLEAN, 0, 0, "d",  
             "Detach Pegasus from the console and run it in the background "},  
         {"logdir", "./logs", false, Option::STRING, 0, 0, "logdir",  
                         "Directory for log files"},  
         {"cleanlogs", "false", false, Option::BOOLEAN, 0, 0, "clean",  
                         "Clears the log files at startup"},  
         {"version", "false", false, Option::BOOLEAN, 0, 0, "v",  
                         "Displays Pegasus Version "},  
         {"help", "false", false, Option::BOOLEAN, 0, 0, "h",  
                     "Prints help message with command line options "},  
         {"install", "false", false, Option::BOOLEAN, 0, 0, "install",  
                     "Installs Pegasus as a Windows NT Service "},  
         {"remove", "false", false, Option::BOOLEAN, 0, 0, "remove",  
                     "Removes Pegasus as a Windows NT Service "},  
         {"debug", "false", false, Option::BOOLEAN, 0, 0, "d",  
                         "Not Used "},  
         {"slp", "false", false, Option::BOOLEAN, 0, 0, "slp",  
                         "Register Pegasus as a Service with SLP"}  
     };  
     const Uint32 NUM_OPTIONS = sizeof(optionsTable) / sizeof(optionsTable[0]);  
   
     om.registerOptions(optionsTable, NUM_OPTIONS);  
   
     String configFile = pegasusHome + "/testclient.conf";  
   
     cout << "Config file from " << configFile << endl;  
   
     if (FileSystem::exists(configFile))  
         om.mergeFile(configFile);  
     if(argc && argv != NULL)  
       om.mergeCommandLine(argc, argv);  
  
     om.checkRequiredOptions();          cm->mergeCommandLine(argc, argv);
       }
       catch (NoSuchFile nsf)
       {
           throw nsf;
       }
       catch (FileNotReadable fnr)
       {
           throw fnr;
       }
       catch (CannotRenameFile ftrf)
       {
           throw ftrf;
       }
       catch (ConfigFileSyntaxError cfse)
       {
           throw cfse;
       }
  
 } }
  
Line 176 
Line 166 
 */ */
 void PrintHelp(const char* arg0) void PrintHelp(const char* arg0)
 { {
     cout << '\n';      /**
           Build the usage string for the config command.
       */
       String usage = String (USAGE);
       usage.append (COMMAND_NAME);
       usage.append (" [ [ options ] | [ configProperty=value, ... ] ]\n");
       usage.append ("  options\n");
       usage.append ("    -v    - prints out the version number\n");
       usage.append ("    -h    - prints this help message\n");
       usage.append ("    -t    - turns tracing on\n");
       usage.append ("    -l    - turns logging on\n");
       usage.append ("  configProperty\n");
       usage.append ("    port=nnnn  - specifies port number to listen on\n");
   
       cout << endl;
     cout << PEGASUS_NAME << PEGASUS_VERSION << endl;     cout << PEGASUS_NAME << PEGASUS_VERSION << endl;
     cout << '\n';  
     cout << "Usage: " << arg0 << endl;  
     cout << endl;     cout << endl;
       cout << usage << endl;
 } }
  
 ///////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////
Line 188 
Line 191 
 ////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
 int main(int argc, char** argv) int main(int argc, char** argv)
 { {
       String pegasusHome  = String::EMPTY;
       Boolean pegasusIOTrace = false;
       Boolean pegasusIOLog = false;
       String portOption = String::EMPTY;
       String logsDirectory = String::EMPTY;
       Boolean useSLP = false;
       Boolean daemonOption = false;
   
     // 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 195 
Line 206 
  
     // Get environment variables     // Get environment variables
  
     String pegasusHome;  
   
     for (int i=0; i < argc; i++) {     for (int i=0; i < argc; i++) {
         if (!strcmp(argv[i],"-D")) {         if (!strcmp(argv[i],"-D")) {
             i++;             i++;
Line 211 
Line 220 
     // removes corresponding options and their arguments fromt he command     // removes corresponding options and their arguments fromt he command
     // line.     // line.
  
     OptionManager om;      //
       // Get an instance of the Config Manager.
       //
       ConfigManager* configManager;
   
       configManager = ConfigManager::getInstance();
  
       //
       // Get options (from command line and from configuration file); this
       // removes corresponding options and their arguments fromt he command
       // line.
       //
     try     try
     {     {
         GetOptions(om, argc, argv, pegasusHome);          GetOptions(configManager, argc, argv, pegasusHome);
         // om.print();  
     }     }
     catch (Exception& e)     catch (Exception& e)
     {     {
Line 237 
Line 255 
         exit(1);         exit(1);
     }     }
  
       try
       {
           //
           // Check to see if user asked for the version (-v option):
           //
   
           if (configManager->isVersionFlagSet())
           {
               cout << PEGASUS_VERSION << endl;
               exit(0);
           }
   
           //
           // Check to see if user asked for help (-h option):
           //
   
           if (configManager->isHelpFlagSet())
           {
               PrintHelp(argv[0]);
               exit(0);
           }
   
           //
     // Check to see if we should (can) install as a NT service     // Check to see if we should (can) install as a NT service
           //
  
     String installOption;          if (String::equal(configManager->getCurrentValue("install"), "true"))
     if(om.lookupValue("install", installOption) && installOption == "true")  
       {       {
         if( 0 != cimserver_install_nt_service( pegasusHome ))         if( 0 != cimserver_install_nt_service( pegasusHome ))
               {
           cout << "\nPegasus installed as NT Service";           cout << "\nPegasus installed as NT Service";
         exit(0);         exit(0);
       }       }
           }
  
           //
     // Check to see if we should (can) remove Pegasus as an NT service     // Check to see if we should (can) remove Pegasus as an NT service
           //
  
     String removeOption;          if (String::equal(configManager->getCurrentValue("remove"), "true"))
     if(om.lookupValue("remove", removeOption) && removeOption == "true")  
       {       {
         if( 0 != cimserver_remove_nt_service() )         if( 0 != cimserver_remove_nt_service() )
               {
           cout << "\nPegasus removed as NT Service";           cout << "\nPegasus removed as NT Service";
         exit(0);         exit(0);
               }
       }       }
  
     // Check to see if user asked for the version (-v otpion):          //
           // Check to see if we should Pegasus as a daemon
     String versionOption;          //
  
     if (om.lookupValue("version", versionOption) && versionOption == "true")          if (String::equal(configManager->getCurrentValue("daemon"), "true"))
     {     {
         cerr << PEGASUS_VERSION << endl;              daemonOption = true;
         exit(0);  
     }     }
  
     // Check to see if user asked for help (-h otpion):          //
     String helpOption;          // Grab the port option:
           //
  
     if (om.lookupValue("help", helpOption) && helpOption == "true")          portOption = configManager->getCurrentValue("port");
     {  
         PrintHelp(argv[0]);  
         om.printHelp();  
         exit(0);  
     }  
  
           //
     // Check the trace options and set global variable     // Check the trace options and set global variable
     Boolean pegasusIOTrace = false;          //
     if (om.valueEquals("trace", "true"))  
           if (configManager->isTraceFlagSet())
     {     {
         Handler::setMessageTrace(true);         Handler::setMessageTrace(true);
         pegasusIOTrace = true;         pegasusIOTrace = true;
               cout << "Trace Set" << endl;
     }     }
           //
           // Check the log trace options and set global variable
           //
  
     Boolean pegasusIOLog = false;          if (configManager->isLogTraceFlagSet())
     if (om.valueEquals("logtrace", "true"))  
     {     {
         Handler::setMessageLogTrace(true);         Handler::setMessageLogTrace(true);
         pegasusIOLog = true;         pegasusIOLog = true;
     }     }
  
     // Grab the port otpion:  
   
     String portOption;  
     om.lookupValue("port", portOption);  
   
     // Get the log file directory definition.     // Get the log file directory definition.
     // We put String into Cstring because     // We put String into Cstring because
     // Directory functions only handle Cstring.     // Directory functions only handle Cstring.
     // ATTN-KS: create String based directory functions.     // ATTN-KS: create String based directory functions.
     String logsDirectory;  
     om.lookupValue("logdir", logsDirectory);          logsDirectory = 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.
     // ATTN: Need tool to completely disable logging.     // ATTN: Need tool to completely disable logging.
     Logger::setHomeDirectory(logsDirectory);     Logger::setHomeDirectory(logsDirectory);
  
     if (om.valueEquals("cleanlogs", "true"))          if (String::equal(configManager->getCurrentValue("cleanlogs"), "true"))
     {     {
         Logger::clean(logsDirectory);;         Logger::clean(logsDirectory);;
     }     }
  
     // Option to Display the options table.  Primarily  
     // a diagnostic tool.  
     if (om.valueEquals("options", "true"))  
         om.print();  
   
     // Leave this in until people get familiar with the logs.     // Leave this in until people get familiar with the logs.
     cout << "Logs Directory = " << logsDirectory << endl;     cout << "Logs Directory = " << logsDirectory << endl;
  
     Boolean useSLP = (om.valueEquals("slp", "true")) ? true: false;          if (String::equal(configManager->getCurrentValue("slp"), "true"))
           {
               useSLP =  true;
           }
       }
       catch (UnrecognizedConfigProperty e)
       {
           cout << "Error: " << e.getMessage() << endl;
       }
  
     char* address = portOption.allocateCString();     char* address = portOption.allocateCString();
  
Line 347 
Line 390 
                 (useSLP ? " SLP on " : " SLP off "));                 (useSLP ? " SLP on " : " SLP off "));
  
 // do we need to run as a daemon ? // do we need to run as a daemon ?
     String daemonOption;      if (daemonOption)
     if(om.lookupValue("daemon", daemonOption) && daemonOption == "true")  
       {       {
         if(-1 == cimserver_fork())         if(-1 == cimserver_fork())
           exit(-1);           exit(-1);
       }       }
  
   
     // try loop to bind the address, and run the server     // try loop to bind the address, and run the server
     try     try
     {     {

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