staftraceservice.cpp

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

    }
    else if(parsedResult->optionTimes("DEFAULTSERVICESTATE") != 0)
    {
        //set default service tracing state
        bool stateToSetTo;
        STAFString defaultServiceState;

        rc = RESOLVE_STRING_OPTION("DEFAULTSERVICESTATE", defaultServiceState);

        if (rc) return STAFServiceResult(rc, errorBuffer);

        defaultServiceState = defaultServiceState.upperCase();

        if(defaultServiceState == "DISABLED")
        {
            stateToSetTo = STAFServiceManager::kTraceDisabled;
        }
        else if (defaultServiceState == "ENABLED")
        {
            stateToSetTo = STAFServiceManager::kTraceEnabled;
        }
        else
        {
            STAFString msg = "Must specify either ENABLED or DISABLED";
            return STAFServiceResult(kSTAFInvalidRequestString, msg);
        }

        STAFServiceManager::setDefaultTraceState(stateToSetTo);
    }

    return STAFServiceResult(kSTAFOk, result);
}



STAFServiceResult STAFTraceService::handleEnableDisable(
    const STAFServiceRequest &requestInfo)
{
    // Parse the request

    STAFCommandParseResultPtr parsedResult = fEnableDisableParser.parse(
        requestInfo.fRequest);

    if (parsedResult->rc != kSTAFOk)
    {
        return STAFServiceResult(kSTAFInvalidRequestString,
                                 parsedResult->errorBuffer, 0);
    }

    STAFString errorBuffer;
    DEFINE_VAR_POOL_LIST(varPoolList, varPoolListSize, requestInfo);
    STAFString result;
    STAFString filename;
    STAFRC_t rc;
    
    // Verify that the requesting machine/user has at least trust level 5
    
    bool stateToSetTo;

    if (parsedResult->optionTimes("ENABLE") != 0)
    {
        stateToSetTo = STAFServiceManager::kTraceEnabled;

        IVALIDATE_TRUST(5, "ENABLE");
    }
    else //DISABLE
    {
        stateToSetTo = STAFServiceManager::kTraceDisabled;

        IVALIDATE_TRUST(5, "DISABLE");
    }

    if (parsedResult->optionTimes("ALL") != 0)
    {
        // Handles ENAGLE|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) return STAFServiceResult(rc, errorBuffer);

            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) return STAFServiceResult(rc, errorBuffer);

                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 (kSTAFTracepointNameMap.find(tracepoint) !=
                    kSTAFTracepointNameMap.end())
            {
                tracepointChangeSet =
                    tracepointChangeSet | kSTAFTracepointNameMap[tracepoint];
            }
            else
                return STAFServiceResult(kSTAFInvalidValue, tracepoint);
        }

        //now handle service tracing

        STAFString serviceList = "";

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

            rc = RESOLVE_STRING_OPTION("SERVICES", services);

            if (rc) return STAFServiceResult(rc, errorBuffer);

            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) return STAFServiceResult(rc, errorBuffer);
            }
        }

        //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 STAFServiceResult(kSTAFOk, result);
}

STAFServiceResult STAFTraceService::handlePurge(
    const STAFServiceRequest &requestInfo)
{
    // Verify that the requesting machine/user has at least trust level 5

    IVALIDATE_TRUST(5, "PURGE");

    STAFServiceManager::purgeUnregisteredServices();

    return STAFServiceResult(kSTAFOk, "");
}


STAFServiceResult STAFTraceService::handleHelp(
    const STAFServiceRequest &requestInfo)
{
    // Verify that the requesting machine/user has at least trust level 1

    IVALIDATE_TRUST(1, "HELP");

    STAFString result("Trace service help" + *gLineSeparatorPtr +
                      *gLineSeparatorPtr);
    
    result += "ENABLE ALL  [ TRACEPOINTS | SERVICES ]" + *gLineSeparatorPtr;
    result += "ENABLE TRACEPOINTS <Trace point list> | SERVICES <Service list>" + *gLineSeparatorPtr;
    result += "ENABLE TRACEPOINT <Trace point> [TRACEPOINT <Trace point>]..." + *gLineSeparatorPtr;
    result += "ENABLE SERVICE <Service> [SERVICE <Service>]..." + *gLineSeparatorPtr;
    result += *gLineSeparatorPtr;
    result += "DISABLE ALL  [ TRACEPOINTS | SERVICES ]" + *gLineSeparatorPtr;
    result += "DISABLE TRACEPOINTS <Trace point list> | SERVICES <Service list>" + *gLineSeparatorPtr;
    result += "DISABLE TRACEPOINT <Trace point> [TRACEPOINT <Trace point>]..." + *gLineSeparatorPtr;
    result += "DISABLE SERVICE <Service> [SERVICE <Service>]..." + *gLineSeparatorPtr;
    result += *gLineSeparatorPtr;
    result += "SET DESTINATION TO < STDOUT | STDERR | FILE <File name> >" + *gLineSeparatorPtr;
    result += "SET DEFAULTSERVICESTATE < Enabled | Disabled >" + *gLineSeparatorPtr;
    result += *gLineSeparatorPtr;
    result += "LIST [SETTINGS]" + *gLineSeparatorPtr;
    result += *gLineSeparatorPtr;
    result += "PURGE" + *gLineSeparatorPtr;
    result += *gLineSeparatorPtr;
    result += "HELP" + *gLineSeparatorPtr;

    return STAFServiceResult(kSTAFOk, result);
}

STAFString STAFTraceService::spaces(int numSpaces)
{
    STAFString str = "";
    for (int i = 0; i < numSpaces; i++)
    {
        str += " ";
    }
    return str;
}

STAFTraceService::STAFTracepointMap STAFTraceService::fillSTAFTracepointMap()
{
    STAFTracepointMap tMap;

    tMap[kSTAFTraceServiceComplete] = "ServiceComplete";
    tMap[kSTAFTraceDebug] = "Debug";
    tMap[kSTAFTraceDeprecated] = "Deprecated";
    tMap[kSTAFTraceError] = "Error";
    tMap[kSTAFTraceInfo] = "Info";
    tMap[kSTAFTraceRegistration] = "Registration";
    tMap[kSTAFTraceRemoteRequests] = "RemoteRequests";
    tMap[kSTAFTraceServiceAccessDenied] = "ServiceAccessDenied";
    tMap[kSTAFTraceServiceError] = "ServiceError";
    tMap[kSTAFTraceServiceManagement] = "ServiceManagement";
    tMap[kSTAFTraceServiceRequest] = "ServiceRequest";
    tMap[kSTAFTraceServiceResult] = "ServiceResult";
    tMap[kSTAFTraceWarning] = "Warning";

    return tMap;
}

STAFTraceService::STAFTracepointNameMap STAFTraceService::fillSTAFTracepointNameMap()
{
    STAFTracepointNameMap tNameMap;
    STAFTracepointMap::iterator tMapIter;

    for (tMapIter = kSTAFTracepointMap.begin();
        tMapIter != kSTAFTracepointMap.end();
        tMapIter++)
    {
        tNameMap[(tMapIter->second).upperCase()] = tMapIter->first;
    }
    return tNameMap;
}

STAFString STAFTraceService::info(unsigned int) const
{
    return (name() + ": Internal");
}

STAFTraceService::~STAFTraceService()
{
   ; /* Do Nothing */
}