(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.5 and 1.16

version 1.5, 2001/04/25 22:20:59 version 1.16, 2001/06/05 12:52:33
Line 21 
Line 21 
 // //
 // Author: Mike Brasher (mbrasher@bmc.com) // Author: Mike Brasher (mbrasher@bmc.com)
 // //
 // Modified By:  // Modified By: Karl Schopmeyer (k.schopmeyer@opengroup.org)
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 31 
Line 31 
 #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/Protocol/Handler.h>
   #include <Pegasus/Common/Logger.h>
   #include <Pegasus/Common/System.h>
   
   PEGASUS_USING_PEGASUS;
   PEGASUS_USING_STD;
  
 using namespace Pegasus;  
 using namespace std;  
  
 const char PEGASUS_VERSION[]  = "Pegasus CIM Server - Version 0.7";  
  
 void GetEnvironmentVariables( void GetEnvironmentVariables(
     const char* arg0,     const char* arg0,
Line 55 
Line 59 
     FileSystem::translateSlashes(pegasusHome);     FileSystem::translateSlashes(pegasusHome);
 } }
  
   /** GetOptions function - This function defines the Options Table
       and sets up the options from that table using the option manager.
   */
 void GetOptions( void GetOptions(
     OptionManager& om,     OptionManager& om,
     int& argc,     int& argc,
     char** argv,     char** argv,
     const String& pegasusHome)     const String& pegasusHome)
 { {
     static struct OptionRow options[] =      static struct OptionRow optionsTable[] =
     {     {
         {"port", "8888", false, Option::WHOLE_NUMBER, 0, 0, "port"},          {"port", "8888", false, Option::WHOLE_NUMBER, 0, 0, "port",
         {"trace", "false", false, Option::BOOLEAN, 0, 0, "trace"},                          "specifies port number to listen on" },
         {"version", "false", false, Option::BOOLEAN, 0, 0, "v"},          {"trace", "false", false, Option::BOOLEAN, 0, 0, "t",
         {"help", "false", false, Option::BOOLEAN, 0, 0, "h"}                          "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 "},
           {"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"},
           {"daemon", "false", false, Option::BOOLEAN, 0, 0, "d",
                           "Not Used "},
           {"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 "},
           {"debug", "false", false, Option::BOOLEAN, 0, 0, "d",
                           "Not Used "}
     };     };
     const Uint32 NUM_OPTIONS = sizeof(options) / sizeof(options[0]);      const Uint32 NUM_OPTIONS = sizeof(optionsTable) / sizeof(optionsTable[0]);
  
     om.registerOptions(options, NUM_OPTIONS);      om.registerOptions(optionsTable, NUM_OPTIONS);
  
     String configFile = pegasusHome + "/cimserver.conf";     String configFile = pegasusHome + "/cimserver.conf";
  
       cout << "Config file from " << configFile << endl;
   
     if (FileSystem::exists(configFile))     if (FileSystem::exists(configFile))
         om.mergeFile(configFile);         om.mergeFile(configFile);
  
Line 82 
Line 111 
     om.checkRequiredOptions();     om.checkRequiredOptions();
 } }
  
   /* PrintHelp - This is temporary until we expand the options manager to allow
      options help to be defined with the OptionRow entries and presented from
      those entries.
   */
 void PrintHelp(const char* arg0) void PrintHelp(const char* arg0)
 { {
     cout << '\n';     cout << '\n';
     cout << PEGASUS_VERSION << endl;      cout << PEGASUS_NAME << PEGASUS_VERSION << endl;
     cout << '\n';  
     cout << "Usage: " << arg0 << " [-port <port_num> -t -h -v]\n";  
     cout << '\n';     cout << '\n';
     cout << "    -h - prints this help message\n";      cout << "Usage: " << arg0 << endl;
     cout << "    -port - specifies port number to listen on\n";  
     cout << "    -v - prints out the version number\n";  
     cout << "    -t - turns on trace mode\n";  
     cout << endl;     cout << endl;
 } }
  
   //////////////////////////////////////////////////////////////////////////
   //  MAIN
   //////////////////////////////////////////////////////////////////////////
 int main(int argc, char** argv) int main(int argc, char** argv)
 { {
     // Get environment variables:     // Get environment variables:
Line 144 
Line 175 
     }     }
  
     // Check to see if user asked for help (-h otpion):     // Check to see if user asked for help (-h otpion):
   
     String helpOption;     String helpOption;
  
     if (om.lookupValue("help", helpOption) && helpOption == "true")     if (om.lookupValue("help", helpOption) && helpOption == "true")
     {     {
         PrintHelp(argv[0]);         PrintHelp(argv[0]);
           om.printHelp();
         exit(0);         exit(0);
     }     }
  
       // Check the trace options and set global variable
       Boolean pegasusIOTrace = false;
       if (om.valueEquals("trace", "true"))
       {
           Handler::setMessageTrace(true);
           pegasusIOTrace = true;
       }
   
       Boolean pegasusIOLog = false;
       if (om.valueEquals("logtrace", "true"))
       {
           Handler::setMessageLogTrace(true);
           pegasusIOLog = true;
       }
   
     // Grab the port otpion:     // Grab the port otpion:
  
     String portOption;     String portOption;
     om.lookupValue("port", portOption);     om.lookupValue("port", portOption);
  
       // Get the log file directory definition.
       // We put String into Cstring because
       // Directory functions only handle Cstring.
       // ATTN-KS: create String based directory functions.
       String logsDirectory;
       om.lookupValue("logdir", logsDirectory);
   
       // 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);
   
       if (om.valueEquals("cleanlogs", "true"))
       {
           Logger::clean(logsDirectory);;
       }
   
       // Leave this in until people get familiar with the logs.
       cout << "Logs Directory = " << logsDirectory << endl;
   
   
       char* address = portOption.allocateCString();
   
       // Put out startup up message.
       cout << PEGASUS_NAME << PEGASUS_VERSION <<
            " on port " << address << endl;
       cout << "Built " << __DATE__ << " " << __TIME__ << endl;
       cout <<"Started..."
            << (pegasusIOTrace ? " Tracing to Display ": " ")
            << (pegasusIOLog ? " Tracing to Log ": " ")
           << endl;
   
       // Option to Display the options table.  Primarily
       // a diagnostic tool.
       if (om.valueEquals("options", "true"))
           om.print();
   
       // Put server start message to the logger
       Logger::put(Logger::STANDARD_LOG, "CIMServer", Logger::INFORMATION,
           "Start $0 $1 port $2 $3 ",
                   PEGASUS_NAME,
                   PEGASUS_VERSION,
                   address,
                   (pegasusIOTrace ? " Tracing": " "));
   
       // try loop to bind the address, and run the server
     try     try
     {     {
         Selector selector;         Selector selector;
         CIMServer server(&selector, pegasusHome);         CIMServer server(&selector, pegasusHome);
  
         char* address = portOption.allocateCString();          // bind throws an exception of the bind fails
         server.bind(address);         server.bind(address);
         delete [] address;         delete [] address;
         server.runForever();         server.runForever();
   
           Logger::put(Logger::STANDARD_LOG, "CIMServer", Logger::INFORMATION,
               "Normal Termination");
   
     }     }
     catch(Exception& e)     catch(Exception& e)
     {     {
         std::cerr << "Error: " << e.getMessage() << std::endl;          Logger::put(Logger::STANDARD_LOG, "CIMServer", Logger::INFORMATION,
               "Abnormal Termination $0", e.getMessage());
   
           PEGASUS_STD(cerr) << "Error: " << e.getMessage() << PEGASUS_STD(endl);
     }     }
  
     return 0;     return 0;

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