fountainAdmin.cpp

Go to the documentation of this file.

/* ex: set tabstop=4 expandtab: */
/*                                                             */
/*  (c) 2004-2006 Iowa State University                        */
/*      see the LICENSE file in the top level directory        */
/*                                                             */
/* $Id: fountainAdmin.cpp 630 2006-06-15 20:51:48Z samm $ */
#include "define.h"
#include "FountainWireProt.h"
#include "NodeID.h"
#include "LokiInclude.h"
#include <bamboo/libbamboo.h>
#include <bamboo/qLog.h>
#include <bamboo/SSSXML.h>
#include <bamboo/ConfigReader.h>
#include <bamboo/TypeConvert.h>
#include <bamboo/ServiceDir.h>
#include <memory>
#include <sstream>
#include <cstddef> //for NULL
#include <iostream>

using namespace BambooLib;
using namespace Loki;
using std::ostringstream;
using std::string;
using std::auto_ptr;
using std::cout;
using std::cerr;
using std::endl;

enum AdminMode {
    invalidMode = 0,
    admin,
    trace,
    bomb,
    set,
    numAdminModes
};

bool parseArgs(int argc, char **argv);

void version(char* name);

void usage(char** argv, AdminMode mode);

const char* fountain_convert(AdminMode t);

 bool fountain_convert(const char* s, AdminMode& a);
 
void cleanUp();

void handleAdminResponse(const ParseMsg* responseMessage);

void handleSetResponse(const ParseMsg* responseMessage);

void handleTraceResponse(const ParseMsg* responseMessage);

void handleBombResponse(const ParseMsg* responseMessage);

//globals
ConfigReader& config(ConfigReader::getInstance());
qLog& qLogger(qLog::getInstance());
ServiceDir& serviceDir(ServiceDir::getInstance());
AdminMode userMode = admin;

//admin globals
bool killServer = false;
bool stats = false;
bool flushDatabase = false;
bool treeTopology = false;
bool rebuildTree = false;
unsigned int rebuildTreeDegree = 0;
qLog_Levels serverLoggingLevel = badLevel;
bool forceDiscover = false;
bool reloadConfig = false;

#if ENABLE_NODE_DAEMONS == 1
//trace globals
bool traceExtendedOutput = false;

//bomb globals
string bombNodeIdValue;
#endif

//set globals
RMAP_Relation_Operator_Type nodeIdOp;
string nodeIdValue;
string nodeStateValue;

//main function
int main(int argc, char** argv) {
    if (BambooLib::Setup() == FAILURE) {
        cerr << "Failed to initialize Bamboo Library\n";
        exit(EXIT_FAILURE);
    }
    
    //if anything below throws an exception, this scope guard will call the cleanUp function
    ScopeGuard cleanupGuard = MakeGuard(&cleanUp);
    
    try {
        //if parseArgs throws an exception, this scope guard will call the usage function
        if (!parseArgs(argc, argv)) {
            usage(argv, userMode);
            return EXIT_FAILURE;
        }
        
                auto_ptr<SSSWireProt> wireProt(ENFORCE(serviceDir.ObtainConnection(NodeMonitor))("Could not connect to Fountain"));

        //send message to server
        BuildMsg requestMessage(sss_convert(envelopeElement));
        requestMessage.NewMasterName(sss_convert(requestElement));
        XMLElement* baseElement = requestMessage.getWorkingElement();
        if (userMode != set) {
            baseElement->addChildElement("Object", sss_convert(serverObject));
        } else {
            baseElement->addChildElement("Object", sss_convert(nodeObject));
        }
        XMLElement* requestDataElement = baseElement->addChildElement(sss_convert(dataElement));
        if (userMode == admin) {
            baseElement->addAttribute("action", FountainMessage::fountain_convert(FountainMessage::admin));
            if (killServer) requestDataElement->addChildElement("KillServer", "true");
            if (flushDatabase) requestDataElement->addChildElement("FlushDatabase", "true");
            if (serverLoggingLevel != badLevel) {
                requestDataElement->addChildElement("ServerLoggingLevel", qLog::levelToText(serverLoggingLevel));
            }
            if (treeTopology) {
                requestDataElement->addChildElement("TreeTopology", "true");
            }
            if (stats) {
                requestDataElement->addChildElement("ServerStats", "true");
            }
            if (rebuildTree) {
                XMLElement* rebuildElement = requestDataElement->addChildElement("RebuildTree", "true");
                if (rebuildTreeDegree != 0) {
                    ostringstream temp;
                    temp << rebuildTreeDegree;
                    rebuildElement->addAttribute("degree", temp.str().c_str());
                }
            }
            if (reloadConfig) {
                requestDataElement->addChildElement("ReloadConfig", "true");
            }
            //add the requested discovery
            if (forceDiscover) {
                XMLElement* serverDataSourceElement = requestDataElement->addChildElement("ServerData");
                if (forceDiscover) {
                    serverDataSourceElement->addChildElement("Discover", "true");
                }
            }
#       if ENABLE_NODE_DAEMONS == 1
        } else if (userMode == trace) {
            baseElement->addAttribute("action", "trace");
        } else if (userMode == bomb) {
            baseElement->addAttribute("action", "bomb");
            if (bombNodeIdValue.empty()) {
               requestDataElement->addChildElement("bombRegEx", ".*");
            } else {
               requestDataElement->addChildElement("bombRegEx", bombNodeIdValue.c_str());
            }
#       endif
        } else if (userMode == set) {
            baseElement->addAttribute("action", "Modify");
            //RMAP_Relation_Operator_Type nodeIdOp;
            //string nodeIdValue;
            //string nodeStateValue;
            if (!nodeIdValue.empty()) {
                XMLElement* whereElementPtr = baseElement->addChildElement(sss_convert(whereElement), nodeIdValue.c_str());
                whereElementPtr->addAttribute("name", "NodeId");
                whereElementPtr->addAttribute("op", sss_convert(nodeIdOp));
            }
            if (!nodeStateValue.empty()) {
                XMLElement* setElementPtr = baseElement->addChildElement(sss_convert(setElement), nodeStateValue.c_str());
                setElementPtr->addAttribute("name", "State");
            } else {
            }
        } else {
            ENFORCE(false)("Unknown userMode");
        }

        ENFORCE(wireProt->sendMessage(&requestMessage))("Error sending ")(fountain_convert(userMode))(" request to fountain server");
        ParseMsg* resultMessage = ENFORCE(wireProt->recvMessage())("Received zero length message response from fountain server");
        if ((qLogger.getLevel() != QLOG_MSGDEBUG) && (!resultMessage->getStatus())) {
            cout << "Received Failure response from fountain server!" << endl;
            if (resultMessage->getResponseMessage()) {
                cout << "Message: " << resultMessage->getResponseMessage() << endl;
            }
        } else {
            if (userMode == admin) {
                handleAdminResponse(resultMessage);
            } else if (userMode == set) {
                handleSetResponse(resultMessage);
#           if ENABLE_NODE_DAEMONS == 1
            } else if (userMode == trace) {
                handleTraceResponse(resultMessage);
            } else if (userMode == bomb) {
                handleBombResponse(resultMessage);
#           endif
            } else {
                ENFORCE(false)("Unknown userMode");
            }
        }
    } catch (const FountainException& e) {
        DebugMessageStream(QLOG_ERR) << e.what();
        exit(EXIT_FAILURE);
    }
    
    //we could let the scope guard call cleanUp() when it goes out of scope, but considering this is
    //normal operation of fountainAdmin, it probably doesn't make sense to do that...  So we'll dismiss
    //the guard and call cleanUp ourself!
    cleanupGuard.Dismiss();
    cleanUp();
    return EXIT_SUCCESS;
}

void cleanUp() {
    BambooLib::Shutdown();
}

void handleAdminResponse(const ParseMsg* responseMessage) {
    if (qLogger.getLevel() != QLOG_MSGDEBUG) {
        XMLElement* dataElement = responseMessage->getDataElement();
        if (dataElement == NULL) {
            cerr << "Missing <Data> element in Fountain server response" << endl;
        } else {
            auto_ptr<XMLElementList> serverStatsList(dataElement->getElementsByName("ServerStats"));
            if ((serverStatsList.get() != NULL) && (serverStatsList->length() > 0)) {
                cout << "Fountain Statistics:" << endl;
                cout << "===============================" << endl;
                XMLElement* serverStats = serverStatsList->item(0);
                auto_ptr<XMLElementList> uptimeList(serverStats->getElementsByName("Uptime"));
                if ((uptimeList.get() != NULL) && (uptimeList->length() > 0)) {
                    const char* uptime = uptimeList->item(0)->getValue();
                    if (uptime != NULL) cout << "Server Uptime: " << uptime << endl;
                }
                
                auto_ptr<XMLElementList> serverLoggingList(serverStats->getElementsByName("ServerLoggingLevel"));
                if ((serverLoggingList.get() != NULL) && (serverLoggingList->length() > 0)) {
                    const char* serverLoggingLevelValue = serverLoggingList->item(0)->getValue();
                    if (serverLoggingLevelValue != NULL) cout << "Server Logging Level: " << serverLoggingLevelValue << endl;
                }
                
                auto_ptr<XMLElementList> managersList(serverStats->getElementsByName("Managers"));
                if ((managersList.get() != NULL) && (managersList->length() > 0)) {
                    const char* managers = managersList->item(0)->getValue();
                    if (managers != NULL) cout << "List of managers: " << managers << endl;
                }
                
                auto_ptr<XMLElementList> nodesList(serverStats->getElementsByName("Nodes"));
                if ((nodesList.get() != NULL) && (nodesList->length() > 0)) {
                    const char* nodes = nodesList->item(0)->getValue();
                    if (nodes != NULL) cout << "Number of nodes in monitor database: " << nodes << endl;
                }
                
                auto_ptr<XMLElementList> queryIntervalList(serverStats->getElementsByName("QueryInterval"));
                if ((queryIntervalList.get() != NULL) && (queryIntervalList->length() > 0)) {
                    const char* queryInterval = queryIntervalList->item(0)->getValue();
                    if (queryInterval != NULL) cout << "Query interval: " << queryInterval << " seconds" << endl;
                }
                
                auto_ptr<XMLElementList> treeRecoveriesList(serverStats->getElementsByName("TreeRecoveries"));
                if ((treeRecoveriesList.get() != NULL) && (treeRecoveriesList->length() > 0)) {
                    const char* treeRecoveries = treeRecoveriesList->item(0)->getValue();
                    if (treeRecoveries != NULL) cout << "Total tree recoveries: " << treeRecoveries << endl;
                }
                
                auto_ptr<XMLElementList> treeRebuildsList(serverStats->getElementsByName("TreeRebuilds"));
                if ((treeRebuildsList.get() != NULL) && (treeRebuildsList->length() > 0)) {
                    const char* treeRebuilds = treeRebuildsList->item(0)->getValue();
                    if (treeRebuilds != NULL) cout << "Total tree rebuilds: " << treeRebuilds << endl;
                }

#                if ENABLE_INFINIBAND == 1
                    auto_ptr<XMLElementList> infinibandStatisticsList(serverStats->getElementsByName("Infiniband"));
                    if ((infinibandStatisticsList.get() != NULL) && (infinibandStatisticsList->length() > 0)) {
                        XMLElement* infinibandElement = infinibandStatisticsList->item(0);
                        auto_ptr<XMLElementList> discoveryElementList(infinibandElement->getElementsByName("Discovery"));
                        if ((discoveryElementList.get() != NULL) && (discoveryElementList->length() > 0)) {
                            XMLElement* discoveryElement = discoveryElementList->item(0);
                            auto_ptr<XMLElementList> discoveryIntervalList(discoveryElement->getElementsByName("Interval"));
                            if ((discoveryIntervalList.get() != NULL) && (discoveryIntervalList->length() > 0)) {
                                const char* discoveryInterval = discoveryIntervalList->item(0)->getValue();
                                if (discoveryInterval) cout << "Infiniband Network discovery interval: " << discoveryInterval << " seconds" << endl;
                            }
                            
                            auto_ptr<XMLElementList> discoveryTimeList(discoveryElement->getElementsByName("Time"));
                            if ((discoveryTimeList.get() != NULL) && (discoveryTimeList->length() > 0)) {
                                const char* discoveryTime = discoveryTimeList->item(0)->getValue();
                                if (discoveryTime) cout << "Infiniband Network discovery time: " << discoveryTime << endl;
                            }
                        }
                        
                        auto_ptr<XMLElementList> pollElementList(infinibandElement->getElementsByName("Poll"));
                        if ((pollElementList.get() != NULL) && (pollElementList->length() > 0)) {
                            XMLElement* pollElement = pollElementList->item(0);
                            auto_ptr<XMLElementList> pollIntervalList(pollElement->getElementsByName("Interval"));
                            if ((pollIntervalList.get() != NULL) && (pollIntervalList->length() > 0)) {
                                const char* pollInterval = pollIntervalList->item(0)->getValue();
                                if (pollInterval) cout << "Infiniband Network poll interval: " << pollInterval << " seconds" << endl;
                            }
                            
                            auto_ptr<XMLElementList> pollTimeList(pollElement->getElementsByName("Time"));
                            if ((pollTimeList.get() != NULL) && (pollTimeList->length() > 0)) {
                                const char* pollTime = pollTimeList->item(0)->getValue();
                                if (pollTime) cout << "Infiniband Network poll time: " << pollTime << endl;
                            }
                        }
                    }
#                endif
                
                auto_ptr<XMLElementList> requestsList(serverStats->getElementsByName("Requests"));
                if ((requestsList.get() != NULL) && (requestsList->length() > 0)) {
                    XMLElement* requests = requestsList->item(0);
                    auto_ptr<XMLElementList> totalRequests(requests->getElementsByName("TotalRequests"));
                    if ((totalRequests.get() != NULL) && (totalRequests->length() > 0)) {
                        cout << "Total requests: " << totalRequests->item(0)->getValue() << endl;
                    }
                    auto_ptr<XMLElementList> totalMalformedRequests(requests->getElementsByName("TotalMalformedRequests"));
                    if ((totalMalformedRequests.get() != NULL) && (totalMalformedRequests->length() > 0)) {
                        cout << "Total malformed requests: " << totalMalformedRequests->item(0)->getValue() << endl;
                    }
                    auto_ptr<XMLElementList> adminRequests(requests->getElementsByName("AdminRequests"));
                    if ((adminRequests.get() != NULL) && (adminRequests->length() > 0)) {
                        cout << "Admin requests: " << adminRequests->item(0)->getValue() << endl;
                    }
                    auto_ptr<XMLElementList> adminMalformedRequests(requests->getElementsByName("AdminMalformedRequests"));
                    if ((adminMalformedRequests.get() != NULL) && (adminMalformedRequests->length() > 0)) {
                        cout << "Admin malformed requests: " << adminMalformedRequests->item(0)->getValue() << endl;
                    }
                    auto_ptr<XMLElementList> nodeMonitorRequests(requests->getElementsByName("NodeMonitorRequests"));
                    if ((nodeMonitorRequests.get() != NULL) && (nodeMonitorRequests->length() > 0)) {
                        cout << "Node monitor requests: " << nodeMonitorRequests->item(0)->getValue() << endl;
                    }
                    auto_ptr<XMLElementList> nodeMonitorMalformedRequests(requests->getElementsByName("NodeMonitorMalformedRequests"));
                    if ((nodeMonitorMalformedRequests.get() != NULL) && (nodeMonitorMalformedRequests->length() > 0)) {
                        cout << "Node monitor malformed requests: " << nodeMonitorMalformedRequests->item(0)->getValue() << endl;
                    }
                }
                
                auto_ptr<XMLElementList> buildDateList(serverStats->getElementsByName("BuildDate"));
                if ((buildDateList.get() != NULL) && (buildDateList->length() > 0)) {
                    XMLElement* buildDate = buildDateList->item(0);
                    if (buildDate->getValue()) {
                        cout << "Build date: " << buildDate->getValue() << endl;
                    }
                }
                
                auto_ptr<XMLElementList> buildArgumentsList(serverStats->getElementsByName("BuildArguments"));
                if ((buildArgumentsList.get() != NULL) && (buildArgumentsList->length() > 0)) {
                    XMLElement* buildArguments = buildArgumentsList->item(0);
                    if (buildArguments->getValue()) {
                        cout << "Build arguments: " << buildArguments->getValue() << endl;
                    }
                }
                
                cout << endl;
            } else if (stats) {
                cerr << "Missing <ServerStats> Data element in Fountain server response" << endl;
            }
            
            //print the results from requesting the fountainNode tree structure
            auto_ptr<XMLElementList> treeTopologyList(dataElement->getElementsByName("TreeTopology"));
            if ((treeTopologyList.get() != NULL) && (treeTopologyList->length() > 0)) {
                cout << "Fountain Tree Structure:" << endl;
                cout << "===============================" << endl;
                XMLElement* treeTopologyXml = treeTopologyList->item(0);
                auto_ptr<XMLElementList> treeTopologyXmlChildren(treeTopologyXml->getElementsByName("Node"));
                if ((treeTopologyXmlChildren.get() != NULL) && (treeTopologyXmlChildren->length() > 0)) {
                    for (unsigned int i=0; i < treeTopologyXmlChildren->length(); i++) {
                        XMLElement* currNode = treeTopologyXmlChildren->item(i);
                        cout << i << " " << currNode->getAttributeValue("ID") << endl;
                    }
                    cout << endl;
                }
            }
        }
        
        if (responseMessage->getResponseMessage() != NULL) {
            cout << "Message:" << endl << responseMessage->getResponseMessage() << endl;
        }
    }
    return;
}

void handleSetResponse(const ParseMsg* responseMessage) {

}

#if ENABLE_NODE_DAEMONS == 1
void handleTraceResponse(const ParseMsg* responseMessage) {
    if (qLogger.getLevel() != QLOG_MSGDEBUG) {
        XMLElement* dataXML = responseMessage->getDataElement();
        auto_ptr<XMLElementList> nodeListList(dataXML->getElementsByName("NodeList"));
        if ((nodeListList.get() != NULL) && (nodeListList->length() > 0)) {
            auto_ptr<XMLElementList> children(nodeListList->item(0)->getChildren());
            for (unsigned int i=0; i < children->length(); i++) {
                XMLElement* node = children->item(i);
                const char* ID = node->getAttributeValue("ID");
                if (ID == NULL) continue;
                if (traceExtendedOutput) {
                    cout << "Node ID: " << ID << endl;
                    auto_ptr<XMLElementList> nodeChildren(node->getChildren());
                    for (unsigned int j=0; j < nodeChildren->length(); j++) {
                        if (nodeChildren->item(j)->isName("Status")) {
                            XMLElement* status = nodeChildren->item(j);
                            auto_ptr<XMLElementList> statusValueList(status->getElementsByName("Value"));
                            if ((statusValueList.get() != NULL) && (statusValueList->length() > 0)) {
                                const char* statusValue = statusValueList->item(0)->getValue();
                                if (statusValue != NULL) cout << "\tStatus: " << statusValue << endl;
                            }
                            auto_ptr<XMLElementList> messageList(status->getElementsByName("Message"));
                            if ((messageList.get() != NULL) && (messageList->length() > 0)) {
                                const char* message = messageList->item(0)->getValue();
                                if (message != NULL) cout << "\tMessage: " << message << endl;
                            }
                        } else if (nodeChildren->item(j)->isName("Parent")) {
                            XMLElement* parent = nodeChildren->item(j);
                            if (parent->getAttributeValue("ID")) {
                                cout << "\tParent: " << parent->getAttributeValue("ID") << endl;
                            }
                        }
                    }
                    cout << endl;
                } else {
                    cout << ID << endl;
                }
            }
            cout << endl << endl;
        } else {
            cout << "Missing NodeList data element in response message!" << endl;
        }
    }
    return;
}

void handleBombResponse(const ParseMsg* responseMessage) {
    if (qLogger.getLevel() != QLOG_MSGDEBUG) {
        XMLElement* dataXML = responseMessage->getDataElement();
        if (dataXML == NULL) {
            cerr << "Missing data element in Fountain server response!" << endl;
        } else {
            auto_ptr<XMLElementList> nodeList(dataXML->getElementsByName("NodeList"));
            if ((nodeList.get() == NULL) || (nodeList->length() <= 0)) {
                cerr << "Missing NodeList element in reply from Fountain server!" << endl;
            } else {
                auto_ptr<XMLElementList> nodeListChildren(nodeList->item(0)->getChildren());
                if ((nodeListChildren.get() == NULL) || (nodeListChildren->length() <= 0)) {
                    cerr << "Missing NodeList child elements in reply from Fountain server!" << endl;
                } else {
                    cout << "The following nodes exited:" << endl;
                    for (unsigned int i=0; i < nodeListChildren->length(); i++) {
                        const char* node = nodeListChildren->item(i)->getAttributeValue("ID");
                        if (node) {
                            const char* exitStatus = nodeListChildren->item(i)->getAttributeValue("Exit");
                            if ((exitStatus) && (!strcmp(exitStatus, "true"))) {
                                cout << node << " ";
                            }
                        }
                    }
                    cout << endl;
                }
            }
        }
    }
    
    return;
}
#endif

bool parseArgs(int argc, char** argv) {
    int argInd = 1;
    char * textpart;
    string configFile;
    bool dumpWireMsg = false;
    
    if (argInd < argc) {
        //first argument can change the mode of fountainAdmin
        if (!fountain_convert(argv[argInd], userMode)) {
            cout << "Could not convert \"" << argv[argInd] << "\" into userMode, assuming admin mode" << endl;
        } else {
            argInd++;
        }
    }
        
    while(argInd < argc) {
        if (argv[argInd][0] == '-') { //check for arg switch
            char arg = argv[argInd][1];
            if (arg == 'v') {
                version(argv[0]);
                return false;
            } else if (arg == 'h') {
                return false;
            } else if (arg == 'd') {
                dumpWireMsg = true;
            } else if ((arg != '-') && (userMode == admin)) {
                switch(arg) {
#                   if ENABLE_NODE_DAEMONS == 1
                    case 't': //print tree
                        treeTopology = true;
                        break;
#                   endif
                    case 'k'://kill server
                        killServer = true;
                    break;
                    case 's'://report statistical info
                        stats = true;
                    break;
                    case 'f'://flush
                        flushDatabase = true;
                    break;
                    default:
                        cerr << "Invalid Argument: " << argv[argInd] << endl;
                        return false;
                    break;
                }
#           if ENABLE_NODE_DAEMONS == 1
            } else if ((arg != '-') && (userMode == trace)) {
                switch(arg) {
                    case 'x': //extended output
                        traceExtendedOutput = true;
                    break;
                    default:
                        cerr << "Invalid Argument: " << argv[argInd] << endl;
                        return false;
                    break;
                }
#           endif
            } else if (arg == '-') {
                textpart = (argv[argInd]+2);
                if (!strcmp(textpart,"help")) {
                    return false;
                } else if (!strcmp(textpart,"version")) {
                    version(argv[0]);
                    return false;
                } else if (!strcmp(textpart, "debug")) {
                    dumpWireMsg = true;
                } else if (!strcmp(textpart,"config")) {
                    if ((argInd+1) == argc) {
                        return false;
                    }
                    configFile = argv[argInd+1];
                    argInd++;
#               if ENABLE_NODE_DAEMONS == 1
                } else if ((userMode == bomb) && !strcmp(textpart, "node")) {
                    if ((argInd+1) == argc) {
                        return false;
                    }
                    bombNodeIdValue = argv[argInd+1];
                    argInd++;
                } else if ((userMode == admin) && !strcmp(textpart, "tree")) {
                    treeTopology = true;
#               endif
                } else if ((userMode == admin) && !strcmp(textpart, "kill")) {
                    killServer = true;
                } else if ((userMode == admin) && !strcmp(textpart, "flush")) {
                    flushDatabase = true;
#               if ENABLE_NODE_DAEMONS == 1
                } else if ((userMode == admin) && !strcmp(textpart, "rebuild")) {
                    rebuildTree = true;
                    //check for optional degree parameter
                    if (argInd+1 < argc) {
                        //make sure the first character of this parameter is a digit, if it isn't
                        //then the degree parameter was probably omitted
                        if (isdigit(argv[argInd+1][0])) {
                            if (!TypeConvert::fromString(argv[argInd+1], rebuildTreeDegree)) {
                                cerr << "Conversion of string " << argv[argInd+1] << " to unsigned int failed" << endl;
                                return false;
                            }
                            argInd++;
                        }
                    }
#               endif
                } else if ((userMode == admin) && !strcmp(textpart, "log")) {
                    if (argInd+1 >= argc) {
                        cerr << "Please give a logging level after --log" << endl;
                        return false;
                    }
                    serverLoggingLevel = qLog::levelFromText(argv[argInd+1]);
                    if (serverLoggingLevel == badLevel) {
                        cerr << "The level \"" << argv[argInd+1] << "\" is not a valid logging level!" << endl;
                        return false;
                    }
                    argInd++;
                } else if ((userMode == admin) && !strcmp(textpart, "stats")) {
                    stats = true;
                } else if ((userMode == admin) && !strcmp(textpart, "discover")) {
                    forceDiscover = true;
                } else if ((userMode == admin) && !strcmp(textpart, "reload")) {
                    reloadConfig = true;
                } else if ((userMode == set) && !strcmp(textpart, "node")) {
                    if ((argInd+1) < argc)    {
                        textpart = argv[argInd+1];
                        while (((argInd+1) < argc) && (textpart[0] != '-')) {
                            if ((nodeIdOp == RO_Invalid) && (sss_convert(textpart, nodeIdOp))) {
                                if ((nodeIdOp != RO_RegEx) && (nodeIdOp != RO_NotEqual) && (nodeIdOp != RO_Equal)) {
                                    cerr << "Please only use like, eq, or ne for --node" << endl;
                                    exit(EXIT_FAILURE);
                                }
                                argInd++;
                            } else if (nodeIdOp == RO_Invalid) {
                                cerr << "Please give --node op before value \"" << textpart << "\"" << endl;
                                return FAILURE;
                            } else {
                                nodeIdValue = textpart;
                                argInd++;
                            }
                            if ((argInd+1) < argc) textpart = argv[argInd+1];
                        }
                        if ((nodeIdOp != RO_Invalid) && (nodeIdValue.length() == 0)) {
                            cerr << "Please give a value to compare the nodeId with" << endl;
                            return FAILURE;
                        }
                    }
                } else if ((userMode == set) && !strcmp(textpart, "state")) {
                    if ((argInd+1) == argc) {
                        return false;
                    }
                    argInd++;
                    nodeStateValue = argv[argInd];
                    if (!nodeStateValue.compare("Up")) {
                        //do nothing
                    } else if (!nodeStateValue.compare("Down")) {
                        //do nothing
                    } else if (!nodeStateValue.compare("Unavailable")) {
                        //do nothing
                    } else if (!nodeStateValue.compare("Invalid")) {
                        //do nothing
                    } else {
                        cerr << "Use either \"Up\", \"Down\", \"Unavailable\", or \"Invalid\" to set node state" << endl;
                        exit(EXIT_FAILURE);
                    }
                    argInd++;
#               if ENABLE_NODE_DAEMONS == 1
                } else if ((userMode == trace) && !strcmp(textpart, "extended")) {
                    traceExtendedOutput = true;
#               endif
                } else {
                    cerr << "Invalid Argument: " << argv[argInd] << endl;
                    return false;
                }
            }
        } else {
            cerr << "Invalid Argument: " << argv[argInd] << endl;
            return false;
        }
        argInd++;
    }
    
    //read config file
    if (configFile.length() == 0) {
        configFile.append(DEFAULT_CONFIG_FILE);
    }
    if (config.readFile(configFile.c_str()) != FAILURE) {
        ostringstream msg;
        cout << "read config file \"" << configFile << "\"" << endl;
    }
    config.readEnvVars();
    
    //setup logger
    if (dumpWireMsg) {
        qLogger.setThreshold(QLOG_MSGDEBUG);
    } else {
        qLogger.setThreshold(QLOG_INFO);
    }
    qLogger.fileOutput(false);
    qLogger.screenOutput(true);
    
    return true;
}

void usage(char** argv, AdminMode mode) {
    switch(mode) {
        case admin:
            cout << argv[0] << " [admin ";
#           if ENABLE_NODE_DAEMONS == 1
            cout << " | trace | bomb ";
#           endif
            cout << "| set] ";
            cout << "[options]" << endl;
            cout << "Options:" << endl;
#           if ENABLE_NODE_DAEMONS == 1
                cout << "\t -t | --tree : Prints the fountain node tree structure." << endl;
#           endif
            cout << "\t -k | --kill : Requests the server to shutdown." << endl;
            cout << "\t -f | --flush : Requests the server to erase its node monitor database and start over from scratch." << endl;
#           if ENABLE_NODE_DAEMONS == 1
                cout << "\t --rebuild [degree] : Requests the master Fountain node to rebuild the tree topology using the optional degree parameter." << endl;
#           endif
            cout << "\t -s | --stats : Requests the server to respond with statistical information." << endl;
            cout << "\t --reload : Force the Fountain server to reload its config file." << endl;
            cout << "\t --discover : Force a server specific datasource discovery." << endl;
            cout << "\t --log <level> : Change the current server logging level." << endl;
            cout << "\t          possible values include:\n"
                 << "\t          QLOG_EMERG, QLOG_ALERT, QLOG_CRIT, QLOG_ERR, QLOG_WARNING,\n"
                 << "\t          QLOG_NOTICE, QLOG_INFO, QLOG_DEBUG, QLOG_MSGDEBUG" << endl;
        break;
        case trace:
            cout << argv[0] << " trace [options]\n";
            cout << "\t -x : Display additional information about each node." << endl;
        break;
        case bomb:
            cout << argv[0] << " bomb [options]\n";
            cout << "\t --node value : Bomb only the specified node ID(s) using regular expression matching." << endl;
        break;
        case set:
            cout << argv[0] << " set [options]\n";
            cout << "\t --node [[op] [value]] : Specify the node to set. Use the \"like\" op for regular expression matching." << endl;
            cout << "\t --state <Up | Down | Unavailable | Invalid> : The node state value to set." << endl;
        break;
        default:
            //unknown admin mode
        break;
    }

    cout << "\t --config <file> : Path to config file, otherwise it's assumed to be " << DEFAULT_CONFIG_FILE << endl;
    cout << "\t -d | --debug : Dump raw messages sent to and from the Fountain server. No other output will be displayed." << endl;
    cout << "\t -v | --version : Display version information." << endl;
    cout << "\t -h | --help : Display this help screen." << endl;    
}

void version(char* name) {
    cout << name << " - Fountain client utility - Version " << FOUNTAIN_VERSION_STRING << endl;
}

const char* fountain_convert(AdminMode t) {
    const char* result =