Changeset 1849

Show
Ignore:
Timestamp:
21/09/2007 20:48:23 (1 year ago)
Author:
chris
Message:

Refactor out command-line option processing, so that it can be extended
by subclasses.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • box/chris/general/lib/server/Daemon.cpp

    r1834 r1849  
    5151          mSingleProcess(false), 
    5252          mRunInForeground(false), 
    53           mKeepConsoleOpenAfterFork(false) 
     53          mKeepConsoleOpenAfterFork(false), 
     54          mHaveConfigFile(false); 
    5455{ 
    5556        if(spDaemon != NULL) 
    …… 
    8889// 
    8990// Function 
     91//              Name:    Daemon::GetOptionString() 
     92//              Purpose: Returns the valid Getopt command-line options. 
     93//                       This should be overridden by subclasses to add 
     94//                       their own options, which should override  
     95//                       ProcessOption, handle their own, and delegate to 
     96//                       ProcessOption for the standard options. 
     97//              Created: 2007/09/18 
     98// 
     99// -------------------------------------------------------------------------- 
     100std::string Daemon::GetOptionString() 
     101{ 
     102        return "c:DFqvVt:Tk"; 
     103} 
     104 
     105// -------------------------------------------------------------------------- 
     106// 
     107// Function 
     108//              Name:    Daemon::ProcessOption(int option) 
     109//              Purpose: Processes the supplied option (equivalent to the 
     110//                       return code from getopt()). Return zero if the 
     111//                       option was handled successfully, or nonzero to 
     112//                       abort the program with that return value. 
     113//              Created: 2007/09/18 
     114// 
     115// -------------------------------------------------------------------------- 
     116int Daemon::ProcessOption(signed int option) 
     117{ 
     118        switch(option) 
     119        { 
     120                case 'c': 
     121                { 
     122                        mConfigFileName = optarg; 
     123                        mHaveConfigFile = true; 
     124                } 
     125                break; 
     126 
     127                case 'D': 
     128                { 
     129                        mSingleProcess = true; 
     130                } 
     131                break; 
     132 
     133                case 'F': 
     134                { 
     135                        mRunInForeground = true; 
     136                } 
     137                break; 
     138 
     139                case 'q': 
     140                { 
     141                        if(mLogLevel == Log::NOTHING) 
     142                        { 
     143                                BOX_FATAL("Too many '-q': " 
     144                                        "Cannot reduce logging " 
     145                                        "level any more"); 
     146                                return 2; 
     147                        } 
     148                        mLogLevel--; 
     149                } 
     150                break; 
     151 
     152                case 'v': 
     153                { 
     154                        if(mLogLevel == Log::EVERYTHING) 
     155                        { 
     156                                BOX_FATAL("Too many '-v': " 
     157                                        "Cannot increase logging " 
     158                                        "level any more"); 
     159                                return 2; 
     160                        } 
     161                        mLogLevel++; 
     162                } 
     163                break; 
     164 
     165                case 'V': 
     166                { 
     167                        mLogLevel = Log::EVERYTHING; 
     168                } 
     169                break; 
     170 
     171                case 't': 
     172                { 
     173                        Console::SetTag(optarg); 
     174                } 
     175                break; 
     176 
     177                case 'T': 
     178                { 
     179                        Console::SetShowTime(true); 
     180                } 
     181                break; 
     182 
     183                case 'k': 
     184                { 
     185                        mKeepConsoleOpenAfterFork = true; 
     186                } 
     187                break; 
     188 
     189                case '?': 
     190                { 
     191                        BOX_FATAL("Unknown option on command line: "  
     192                                << "'" << (char)optopt << "'"); 
     193                        return 2; 
     194                } 
     195                break; 
     196 
     197                default: 
     198                { 
     199                        BOX_FATAL("Unknown error in getopt: returned " 
     200                                << "'" << option << "'"); 
     201                        return 1; 
     202                } 
     203        } 
     204 
     205        return 0; 
     206} 
     207 
     208// -------------------------------------------------------------------------- 
     209// 
     210// Function 
    90211//              Name:    Daemon::Main(const char *, int, const char *[]) 
    91212//              Purpose: Parses command-line options, and then calls 
    …… 
    99220        // Find filename of config file 
    100221        mConfigFileName = DefaultConfigFile; 
    101         bool haveConfigFile = false; 
    102222 
    103223        #ifdef NDEBUG 
    104         int masterLevel = Log::NOTICE; // need an int to do math with 
     224        mLogLevel = Log::NOTICE; // need an int to do math with 
    105225        #else 
    106         int masterLevel = Log::INFO; // need an int to do math with 
     226        mLogLevel = Log::INFO; // need an int to do math with 
    107227        #endif 
    108228 
    …… 
    119239        #endif 
    120240 
    121         while((c = getopt(argc, (char * const *)argv, "c:DFqvVt:Tk")) != -1) 
    122         { 
    123                 switch(c) 
    124                 { 
    125                         case 'c': 
    126                         { 
    127                                 mConfigFileName = optarg; 
    128                                 haveConfigFile = true; 
    129                         } 
    130                         break; 
    131  
    132                         case 'D': 
    133                         { 
    134                                 mSingleProcess = true; 
    135                         } 
    136                         break; 
    137  
    138                         case 'F': 
    139                         { 
    140                                 mRunInForeground = true; 
    141                         } 
    142                         break; 
    143  
    144                         case 'q': 
    145                         { 
    146                                 if(masterLevel == Log::NOTHING) 
    147                                 { 
    148                                         BOX_FATAL("Too many '-q': " 
    149                                                 "Cannot reduce logging " 
    150                                                 "level any more"); 
    151                                         return 2; 
    152                                 } 
    153                                 masterLevel--; 
    154                         } 
    155                         break; 
    156  
    157                         case 'v': 
    158                         { 
    159                                 if(masterLevel == Log::EVERYTHING) 
    160                                 { 
    161                                         BOX_FATAL("Too many '-v': " 
    162                                                 "Cannot increase logging " 
    163                                                 "level any more"); 
    164                                         return 2; 
    165                                 } 
    166                                 masterLevel++; 
    167                         } 
    168                         break; 
    169  
    170                         case 'V': 
    171                         { 
    172                                 masterLevel = Log::EVERYTHING; 
    173                         } 
    174                         break; 
    175  
    176                         case 't': 
    177                         { 
    178                                 Console::SetTag(optarg); 
    179                         } 
    180                         break; 
    181  
    182                         case 'T': 
    183                         { 
    184                                 Console::SetShowTime(true); 
    185                         } 
    186                         break; 
    187  
    188                         case 'k': 
    189                         { 
    190                                 mKeepConsoleOpenAfterFork = true; 
    191                         } 
    192                         break; 
    193  
    194                         case '?': 
    195                         { 
    196                                 BOX_FATAL("Unknown option on command line: "  
    197                                         << "'" << (char)optopt << "'"); 
    198                                 return 2; 
    199                         } 
    200                         break; 
    201  
    202                         default: 
    203                         { 
    204                                 BOX_FATAL("Unknown error in getopt: returned " 
    205                                         << "'" << c << "'"); 
    206                                 return 1; 
    207                         } 
    208                 } 
    209         } 
    210  
    211         if (argc > optind && !haveConfigFile) 
     241        while((c = getopt(argc, (char * const *)argv,  
     242                GetOptionString().c_str())) != -1) 
     243        { 
     244                int returnCode = ProcessOption(c); 
     245 
     246                if (returnCode != 0) 
     247                { 
     248                        return returnCode; 
     249                } 
     250        } 
     251 
     252        if (argc > optind && !mHaveConfigFile) 
    212253        { 
    213254                mConfigFileName = argv[optind]; optind++; 
    …… 
    226267        } 
    227268 
    228         Logging::SetGlobalLevel((Log::Level)masterLevel); 
     269        Logging::SetGlobalLevel((Log::Level)mLogLevel); 
    229270 
    230271        return Main(mConfigFileName); 

  • box/chris/general/lib/server/Daemon.h

    r1741 r1849  
    6868        box_time_t GetLoadedConfigModifiedTime() const; 
    6969        bool IsSingleProcess() { return mSingleProcess; } 
     70        std::string GetOptionString(); 
     71        int ProcessOption(signed int option); 
    7072         
    7173private: 
    …… 
    7375        box_time_t GetConfigFileModifiedTime() const; 
    7476         
    75 private: 
    7677        std::string mConfigFileName; 
    7778        Configuration *mpConfiguration; 
    …… 
    8283        bool mRunInForeground; 
    8384        bool mKeepConsoleOpenAfterFork; 
     85        bool mHaveConfigFile; 
     86        int mLogLevel; // need an int to do math with 
    8487        static Daemon *spDaemon; 
    8588};