stafconfig.cpp

Software Testing Automation Framework (STAF)的开发代码

    fTraceParser.addOption("TO", 1,
        STAFCommandParser::kValueNotAllowed);
    fTraceParser.addOption("STDOUT", 1,
        STAFCommandParser::kValueNotAllowed);
    fTraceParser.addOption("STDERR", 1,
        STAFCommandParser::kValueNotAllowed);
    fTraceParser.addOption("FILE", 1,
        STAFCommandParser::kValueRequired);
    fTraceParser.addOption("DEFAULTSERVICESTATE", 1,
        STAFCommandParser::kValueRequired);

    // trace groups
    fTraceParser.addOptionGroup("ENABLE DISABLE", 0, 1);
    fTraceParser.addOptionGroup("STDOUT STDERR FILE", 0, 1);
    fTraceParser.addOptionGroup("DEFAULTSERVICESTATE DESTINATION", 0, 1);

    // trace needs
    fTraceParser.addOptionNeed("ENABLE DISABLE",
        "ALL TRACEPOINT SERVICE TRACEPOINTS SERVICES");
    fTraceParser.addOptionNeed("SET", "TO DEFAULTSERVICESTATE");
    fTraceParser.addOptionNeed("DESTINATION", "SET");
    fTraceParser.addOptionNeed("TO", "DESTINATION");
    fTraceParser.addOptionNeed("TO", "STDOUT STDERR FILE");
    fTraceParser.addOptionNeed("STDOUT STDERR FILE DEFAULTSERVICESTATE", "SET");


    STAFCommandParseResultPtr parsedResult = fTraceParser.parse(line);

    if (parsedResult->rc != kSTAFOk)
    {
        cout << "Error on TRACE definition, " << line << endl
             << parsedResult->errorBuffer << endl;
        return 1;
    }

    STAFString errorBuffer;
    STAFString filename;
    STAFString tracepointList;
    STAFString serviceList;
    STAFRC_t rc = RESOLVE_OPTIONAL_STRING_OPTION("FILE", filename);

    if (rc != kSTAFOk)
    {
        cout << "Error on TRACE definition, " << line << endl
             << "Error with, " << errorBuffer << ", RC: " << rc << endl;
        return 1;
    }

    if (parsedResult->optionTimes("TO") != 0)
    {
        //set tracing information destination
        if (parsedResult->optionTimes("STDOUT") != 0)
            STAFTrace::setTraceDestination(kSTAFTraceToStdout);
        else if (parsedResult->optionTimes("STDERR") != 0)
            STAFTrace::setTraceDestination(kSTAFTraceToStderr);
        else
            STAFTrace::setTraceDestination(kSTAFTraceToFile, filename);
    }
    else if (parsedResult->optionTimes("DEFAULTSERVICESTATE") != 0)
    {
        //set default service tracing state
        bool stateToSetTo;
        STAFString defaultServiceState;

        rc = RESOLVE_STRING_OPTION("DEFAULTSERVICESTATE", defaultServiceState);

        if (rc != kSTAFOk)
        {
            cout << "Error on TRACE definition, " << line << endl
                 << "Error with, " << errorBuffer << ", RC: " << rc << endl;
            return 1;
        }

        defaultServiceState = defaultServiceState.upperCase();

        if(defaultServiceState == "DISABLED")
        {
            stateToSetTo = STAFServiceManager::kTraceDisabled;
        }
        else if (defaultServiceState == "ENABLED")
        {
            stateToSetTo = STAFServiceManager::kTraceEnabled;
        }
        else
        {
            cout << "Error on TRACE definition, " << line << endl
                 << "You must specify ENABLE or DISABLE"
                 << rc << endl;
            return kSTAFInvalidRequestString;
        }

        STAFServiceManager::setDefaultTraceState(stateToSetTo);
    }
    else
    {
        //set tracing of services and tracepoints
        bool stateToSetTo;

        if (parsedResult->optionTimes("ENABLE") != 0)
        {
            stateToSetTo = STAFServiceManager::kTraceEnabled;
        }
        else if (parsedResult->optionTimes("DISABLE") != 0)
        {
            stateToSetTo = STAFServiceManager::kTraceDisabled;
        }
        else
        {
            rc = kSTAFInvalidRequestString;
            cout << "Error on TRACE definition, " << line << endl
                 << "You must specify either ENABLE or DISABLE, RC: " << rc << endl;
            return rc;
        }

        if (parsedResult->optionTimes("ALL") != 0)
        //Handles ENABLE|DISABLE ALL ...
        {
            bool doTracepoints = false, doServices = false;

            if ((parsedResult->optionTimes("TRACEPOINTS") == 0) &&
                (parsedResult->optionTimes("SERVICES") == 0))
            {
                doTracepoints = true;
                doServices = true;
            }

            if (parsedResult->optionTimes("SERVICES") != 0)
                doServices = true;
            if (parsedResult->optionTimes("TRACEPOINTS") != 0)
                doTracepoints = true;

            if (doTracepoints)
            {
                if(stateToSetTo == STAFServiceManager::kTraceEnabled)
                       STAFTrace::traceOn(kSTAFTraceAll);
                else
                       STAFTrace::traceOff(kSTAFTraceAll);
            }
            if (doServices)
                STAFServiceManager::traceServicesChangeAll(stateToSetTo);
        }

        else
        {
            STAFString tracepointList = "";
            STAFTracePoint_t tracepointChangeSet = kSTAFTraceNone;

            if (parsedResult->optionTimes("TRACEPOINTS") != 0)
            {

                STAFString tracepoints;

                rc = RESOLVE_STRING_OPTION("TRACEPOINTS", tracepoints);

                if (rc != kSTAFOk)
                {
                    cout << "Error on TRACE definition, " << line << endl
                         << "Error with, " << errorBuffer << ", RC: "
                         << rc << endl;
                    return 1;
                }

                tracepointList = tracepoints;
            }

            if (parsedResult->optionTimes("TRACEPOINT") != 0)
            {
                STAFString tracepoint;
                for (int i = 1, optionCount =
                    parsedResult->optionTimes("TRACEPOINT"); i <= optionCount; ++i)
                {
                    rc = RESOLVE_INDEXED_STRING_OPTION("TRACEPOINT", i, tracepoint);

                    if (rc != kSTAFOk)
                    {
                        cout << "Error on TRACE definition, " << line << endl
                             << "Error with, " << errorBuffer << ", RC: "
                             << rc << endl;
                        return 1;
                    }

                    tracepointList += " " + tracepoint;
                }
            }

            tracepointList = tracepointList.upperCase();

            //validate list of tracepoints
            for (int i = 0; i < tracepointList.numWords(); ++i )
            {
                STAFString tracepoint = tracepointList.subWord(i, 1).upperCase();

                if (STAFTraceService::kSTAFTracepointNameMap.find(tracepoint) !=
                        STAFTraceService::kSTAFTracepointNameMap.end())
                {
                    tracepointChangeSet =
                        tracepointChangeSet |
                        STAFTraceService::kSTAFTracepointNameMap[tracepoint];
                }
                else
                {
                    cout << "Error on TRACE definition, " << line << endl
                         << "tracepoint " << tracepoint
                         << " does not exist, RC: " << kSTAFInvalidValue
                         << endl;
                    return 1;
                }
            }

            //now handle service tracing

            STAFString serviceList = "";

            if (parsedResult->optionTimes("SERVICES") != 0)
            {
                STAFString services;

                rc = RESOLVE_STRING_OPTION("SERVICES", services);

                if (rc != kSTAFOk)
                {
                    cout << "Error on TRACE definition, " << line << endl
                         << "Error with, " << errorBuffer << ", RC: " << rc << endl;
                    return 1;
                }

                serviceList = services;
            }

            if (parsedResult->optionTimes("SERVICE") != 0)
            {
                STAFString service;

                for (int i = 1, optionCount =
                    parsedResult->optionTimes("SERVICE"); i<= optionCount; ++i)
                {

                    rc = RESOLVE_INDEXED_STRING_OPTION("SERVICE", i, service);
                    serviceList += " " + service;

                    if (rc != kSTAFOk)
                    {
                        cout << "Error on TRACE definition, " << line << endl
                             << "Error with, " << errorBuffer << ", RC: " << rc << endl;
                        return 1;
                    }
                }
            }

            //after ensuring there are no errors, make desired changes
            serviceList = serviceList.upperCase();

            STAFServiceManager::traceServicesChange(serviceList, stateToSetTo);

            if(stateToSetTo == STAFServiceManager::kTraceEnabled)
                STAFTrace::traceOn(tracepointChangeSet);
            else
                STAFTrace::traceOff(tracepointChangeSet);
        }
    }
    return kSTAFOk;
}

unsigned int handleServiceConfig(STAFString line)
{
    STAFCommandParser fServiceParser;

    // SERVICE <Name>
    // LIBRARY <Library> [EXECUTE <Exec>] {OPTION <OpName[=OpValue]>}
    //     [PARMS <Parms>]
    // or
    // DELEGATE <Machine> [TONAME <Service Name>]

    // service config options

    fServiceParser.addOption("SERVICE",  1,
        STAFCommandParser::kValueRequired);
    fServiceParser.addOption("LIBRARY",    1,
        STAFCommandParser::kValueRequired);
    fServiceParser.addOption("EXECUTE",    1,
        STAFCommandParser::kValueRequired);
    fServiceParser.addOption("OPTION",    0,
        STAFCommandParser::kValueRequired);
    fServiceParser.addOption("PARMS",    1,
        STAFCommandParser::kValueRequired);
    fServiceParser.addOption("DELEGATE", 1,
        STAFCommandParser::kValueRequired);
    fServiceParser.addOption("TONAME",   1,
        STAFCommandParser::kValueRequired);

    // service config groups

    fServiceParser.addOptionGroup("SERVICE",          1, 1);
    fServiceParser.addOptionGroup("LIBRARY DELEGATE", 1, 1);

    // service config needs

    fServiceParser.addOptionNeed("EXECUTE OPTION PARMS",  "LIBRARY");
    fServiceParser.addOptionNeed("TONAME", "DELEGATE");

    STAFCommandParseResultPtr parsedResult = fServiceParser.parse(line);

    if (parsedResult->rc != kSTAFOk)
    {
        cout << "Error on Service definition, " << line << endl
             << parsedResult->errorBuffer << endl;
        return 1;
    }

    STAFString errorBuffer;
    STAFString name;
    STAFRC_t rc = RESOLVE_STRING_OPTION("SERVICE", name);

    if (rc)
    {
        cout << "Error on Service definition, " << line << endl
             << "Error resolving " << parsedResult->optionValue("SERVICE")
             << ", RC: " << rc << endl;
        return 1;
    }

    rc = gServiceManagerPtr->verifyServiceName(name);

    if (rc)
    {
        cout << "Error on Service definition, " << line << endl
             << "Service name " << name << " is not valid, RC: " << rc << endl;
        cout << INVALID_SERVICE_NAME_ERROR_MESSAGE() << endl;

        return 1;
    }

    try
    {
        STAFServicePtr service;

        if (parsedResult->optionTimes("LIBRARY") != 0)
        {
            // Setup external service data
            STAFString library;
            STAFString exec;
            STAFString parms;
            STAFExternalService::OptionList options;

            rc = RESOLVE_STRING_OPTION("LIBRARY", library);

            if (!rc) rc = RESOLVE_STRING_OPTION("EXECUTE", exec);

            // The service will resolve PARMS

            if (parsedResult->optionTimes("PARMS") > 0)
            {
                parms = parsedResult->optionValue("PARMS");
            }

            for (int i = 1; !rc && (i <= parsedResult->optionTimes("OPTION"));
                 ++i)
            {
                STAFString option;
                rc = RESOLVE_INDEXED_STRING_OPTION("OPTION", i, option);
                options.push_back(option);
            }

            if (rc)
            {
                cout << "Error on Service definition, " << line << endl
                     << "Error with " << errorBuffer << ", RC: " << rc
                     << endl;
                return 1;
            }

            service = STAFServicePtr(new STAFExternalService(name, library,
                                     exec, options, parms,
                                     kSTAFServiceTypeService),
                                     STAFServicePtr::INIT);
        }
        else
        {
            // This is a Delegated service

            STAFString toMachine;
            STAFString toName = name;

            rc = RESOLVE_STRING_OPTION("DELEGATE", toMachine);

            if (!rc) RESOLVE_OPTIONAL_STRING_OPTION("TONAME", toName);

            if (rc)
            {
                cout << "Error on Service definition, " << line << endl
                     << "Error with " << errorBuffer << ", RC: " << rc << endl;
                return 1;
            }

            service = STAFServicePtr(new STAFDelegatedService(name, toMachine,
                                     toName), STAFServicePtr::INIT);
        }

        rc = gServiceManagerPtr->add(service);

        if (rc)
        {
            cout << "Error, RC: " << rc << ", adding Service definition, "
                 << line << endl;
            return 1;
        }
    }
    catch (STAFServiceCreateException &e)
    {
        cout << "Error on Service definition, " << line << endl
             << e.getErrorCode() << ":" << e.getText() << endl;
        return 1;
    }
    catch (STAFException &e)
    {
        e.write();
        return 1;
    }
    catch (...)
    {
        // XXX: Why is this here?
        cout << "Exception caught. Need to get this out (STAFConfig.cpp)"
             << endl;
        return 1;
    }

    return 0;
}


unsigned int handleServiceLoaderConfig(STAFString line)
{
    STAFCommandParser fServiceLoaderParser;

    // SERVICELOADER
    // LIBRARY <Library> [EXECUTE <Exec>] {OPTION <OpName[=OpValue]>}
    //     [PARMS <Parms>]

    // serviceloader config options

    fServiceLoaderParser.addOption("SERVICELOADER",  1,
        STAFCommandParser::kValueNotAllowed);
    fServiceLoaderParser.addOption("LIBRARY",    1,
        STAFCommandParser::kValueRequired);
    fServiceLoaderParser.addOption("EXECUTE",    1,
        STAFCommandParser::kValueRequired);
    fServiceLoaderParser.addOption("OPTION",    0,
        STAFCommandParser::kValueRequired);
    fServiceLoaderParser.addOption("PARMS",    1,
        STAFCommandParser::kValueRequired);

    // service config groups

    fServiceLoaderParser.addOptionGroup("SERVICELOADER", 1, 1);
    fServiceLoaderParser.addOptionGroup("LIBRARY", 1, 1);

    // service config needs

    fServiceLoaderParser.addOptionNeed("EXECUTE OPTION PARMS",  "LIBRARY");

    STAFCommandParseResultPtr parsedResult = fServiceLoaderParser.parse(line);

    if (parsedResult->rc != kSTAFOk)
    {
        cout << "Error on ServiceLoader definition, " << line << endl
             << parsedResult->errorBuffer << endl;
        return 1;
    }

    try
    {
        STAFServicePtr service;

        // Setup external service data
        STAFString library;
        STAFString exec;
        STAFString parms;
        STAFExternalService::OptionList options;
        STAFString errorBuffer;
        STAFRC_t rc = RESOLVE_STRING_OPTION("LIBRARY", library);

        if (!rc) rc = RESOLVE_STRING_OPTION("EXECUTE", exec);
        if (!rc) rc = RESOLVE_STRING_OPTION("PARMS", parms);