(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.8

version 1.34, 2001/07/17 00:49:05 version 1.34.2.8, 2001/08/28 15:20:23
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 68 
Line 70 
 #include <iostream> #include <iostream>
 #include <cstdlib> #include <cstdlib>
 #include <Pegasus/Common/FileSystem.h> #include <Pegasus/Common/FileSystem.h>
 #include <Pegasus/Common/Selector.h>  #include <Pegasus/Common/Monitor.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 93 
 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: ";
   
   /**
   Constants representing the command line options.
   */
   static const char OPTION_VERSION     = 'v';
   
   static const char OPTION_HELP        = 'h';
   
   static const char OPTION_HOME        = 'D';
   
   
   
 void GetEnvironmentVariables( void GetEnvironmentVariables(
     const char* arg0,     const char* arg0,
     String& pegasusHome)     String& pegasusHome)
Line 108 
Line 132 
     FileSystem::translateSlashes(pegasusHome);     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 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;
         {"home", "/etc/pegasus", false, Option::STRING, 0, 0, "D",  
                     "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();      try
       {
           cm->mergeConfigFiles(currentFile, plannedFile);
  
           cm->mergeCommandLine(argc, argv);
       }
       catch (NoSuchFile nsf)
       {
           throw nsf;
       }
       catch (FileNotReadable fnr)
       {
           throw fnr;
       }
       catch (CannotRenameFile ftrf)
       {
           throw ftrf;
       }
       catch (ConfigFileSyntaxError cfse)
       {
           throw cfse;
       }
       catch(UnrecognizedConfigProperty ucp)
       {
           throw ucp;
       }
       catch(InvalidPropertyValue ipv)
       {
           throw ipv;
       }
 } }
  
 /* PrintHelp - This is temporary until we expand the options manager to allow /* PrintHelp - This is temporary until we expand the options manager to allow
Line 176 
Line 195 
 */ */
 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          - displays pegasus version number\n");
       usage.append ("    -h          - prints this help message\n");
       usage.append ("    -D [home]   - sets pegasus home directory\n");
       usage.append ("    -t          - turns tracing on\n");
       usage.append ("    -t          - turns on trace of client IO to console\n");
       usage.append ("    -l          - turns on trace of client IO to trace file\n");
       usage.append ("    -d          - runs pegasus as a daemon\n");
       usage.append ("    -cleanlogs  - clears the log files at startup\n");
       usage.append ("    -install    - installs pegasus as a Windows NT Service\n");
       usage.append ("    -remove     - removes pegasus as a Windows NT Service\n");
       usage.append ("    -slp        - registers pegasus as a service with SLP\n\n");
   
       usage.append ("  configProperty=value\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");
   
       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 230 
 ////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
 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 )
       cim_server_service(argc, argv) ;       cim_server_service(argc, argv) ;
  
     // Get environment variables      // Get help, version and home options
  
     String pegasusHome;      for (int i = 0; i < argc; )
       {
           const char* arg = argv[i];
  
     for (int i=0; i < argc; i++) {          // Check for -option
         if (!strcmp(argv[i],"-D")) {          if (*arg == '-')
             i++;          {
             if (i < argc) pegasusHome = argv[i];              // Get the option
             break;              const char* option = arg + 1;
   
               //
               // Check to see if user asked for the version (-v option):
               //
               if (*option == OPTION_VERSION)
               {
                   cout << PEGASUS_VERSION << endl;
                   exit(0);
               }
               //
               // Check to see if user asked for help (-h option):
               //
               else if (*option == OPTION_HELP)
               {
                   PrintHelp(argv[0]);
                   exit(0);
         }         }
               else if (*option == OPTION_HOME)
               {
                   if (i + 1 < argc)
                   {
                       pegasusHome.assign(argv[i + 1]);
                       SetEnvironmentVariables(argv[i + 1]);
                   }
                   else
                   {
                       cout << "Missing argument for option -" << option << endl;
                       exit(0);
     }     }
   
                   memmove(&argv[i], &argv[i + 2], (argc-i-1) * sizeof(char*));
                   argc -= 2;
               }
           }
           i++;
       }
   
     if (pegasusHome.size() == 0)     if (pegasusHome.size() == 0)
         GetEnvironmentVariables(argv[0], pegasusHome);         GetEnvironmentVariables(argv[0], pegasusHome);
  
       //
       // Get an instance of the Config Manager.
       //
       ConfigManager* configManager = ConfigManager::getInstance();
   
       //
     // 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 fromt he command     // removes corresponding options and their arguments fromt he command
     // line.     // line.
       //
     OptionManager om;  
   
     try     try
     {     {
         GetOptions(om, argc, argv, pegasusHome);          GetOptions(configManager, argc, argv, pegasusHome);
         // om.print();  
     }     }
     catch (Exception& e)     catch (Exception& e)
     {     {
Line 224 
Line 314 
         exit(1);         exit(1);
     }     }
  
     // At this point, all options should have been extracted; print an  
     // error if there are any remaining:  
  
     if (argc != 1)      try
     {     {
         cerr << argv[0] << ": unrecognized options: ";          //
   
         for (int i = 1; i < argc; i++)  
             cerr << argv[i] << ' ';  
         cout << endl;  
         exit(1);  
     }  
   
     // 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 (String::equal(configManager->getCurrentValue("trace"), "true"))
     {     {
         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 (String::equal(configManager->getCurrentValue("logtrace"), "true"))
     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 431 
                 (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
     {     {
Line 368 
Line 450 
         char *url = serviceURL.allocateCString();         char *url = serviceURL.allocateCString();
         //      free(host_name);         //      free(host_name);
  
         Selector selector;          Monitor monitor;
         CIMServer server(&selector, pegasusHome);          CIMServer server(&monitor, pegasusHome);
  
         // bind throws an exception of the bind fails         // bind throws an exception of the bind fails
         cout << "Binding to " << address << endl;         cout << "Binding to " << address << endl;
         server.bind(address);  
           char* end = 0;
           long portNumber = strtol(address, &end, 10);
           assert(end != 0 && *end == '\0');
           server.bind(portNumber);
   
         delete [] address;         delete [] address;
  
         time_t last = 0;         time_t last = 0;
Line 385 
Line 472 
             {             {
               if( discovery != NULL && url != NULL )               if( discovery != NULL && url != NULL )
                 discovery->srv_reg_all(url,                 discovery->srv_reg_all(url,
                                        "(namespace=root/cimv20)",                                         "(namespace=root/cimv2)",
                                        "service:cim.pegasus",                                        "service:cim.pegasus",
                                        "DEFAULT",                                        "DEFAULT",
                                        70) ;                                        70) ;

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