stafdiagservice.cpp

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

        STAFString sourceLowerCase = source.toLowerCase();
        unsigned int triggerCount  = 0;
        DiagDataVector diagDataVector;
        STAFDiagManager::DiagMap::iterator mIter;
       
        for (mIter = diagMap.begin(); mIter != diagMap.end(); mIter++)
        {
            if (sourceLowerCase == mIter->second.source.toLowerCase())
            {
                diagDataVector.push_back(mIter->second);
                triggerCount++;
            }
        }

        // Sort the diagDataVector (already sorted by trigger)

        switch (sortBy)
        {
            case kSTAFDiagSortByCount:
            {
                std::sort(diagDataVector.begin(), diagDataVector.end(),
                          descendingCountSort);
                break;
            }

            case kSTAFDiagSortBySource:
            {
                // Source by count since only only source

                std::sort(diagDataVector.begin(), diagDataVector.end(),
                          descendingCountSort);
                break;
            }
             
            default: break;
        }

        // Create a marshalled map containing diagnostics info for
        // the specified source

        mc->setMapClassDefinition(fSourceInfoClass->reference());
        mc->setMapClassDefinition(fTriggerCountClass->reference());

        STAFObjectPtr sourceInfoMap = fSourceInfoClass->createInstance();

        if (startTime != sNotApplicable)
            sourceInfoMap->put("fromTimestamp", startTime);

        sourceInfoMap->put("toTimestamp", stopTime);

        if (elapsedTime != sNotApplicable)
            sourceInfoMap->put("elapsedTime", elapsedTime);

        sourceInfoMap->put("source", source);
        sourceInfoMap->put("numberOfTriggers", STAFString(triggerCount));
       
        // Iterate thru the sorted diagDataVector and generate the result

        DiagDataVector::iterator vIter;
        STAFObjectPtr outputList = STAFObject::createList();
        
        for (vIter = diagDataVector.begin(); vIter != diagDataVector.end();
             vIter++)
        {
            STAFObjectPtr triggerCountMap =
                fTriggerCountClass->createInstance();
            triggerCountMap->put("count", STAFString(vIter->count));
            triggerCountMap->put("trigger", vIter->trigger);

            outputList->append(triggerCountMap);
        }

        sourceInfoMap->put("triggerList", outputList);

        mc->setRootObject(sourceInfoMap);
    }
    else if (parsedResult->optionTimes("TRIGGERS") != 0)
    {
        // List all the triggers

        unsigned int triggerCount = 0;
        STAFDiagManager::DiagMap triggerMap;
        STAFDiagManager::DiagMap::iterator mIter;
       
        // Create a map of unique triggers, accumulating counts by trigger

        for (mIter = diagMap.begin(); mIter != diagMap.end(); mIter++)
        {
            if (triggerMap.find(mIter->second.trigger.toLowerCase()) ==
                triggerMap.end())
            {
                triggerMap[mIter->second.trigger.toLowerCase()] =
                    mIter->second;
            }
            else
            {
                triggerMap[mIter->second.trigger.toLowerCase()].count +=
                    mIter->second.count;
            }
        }
        
        // Iterate thru the TriggerMap and create a vector of triggers

        DiagDataVector diagDataVector;
       
        for (mIter = triggerMap.begin(); mIter != triggerMap.end(); mIter++)
        {
            diagDataVector.push_back(mIter->second);
        }

        // Sort the diagDataVector (already sorted by trigger)

        switch (sortBy)
        {
            case kSTAFDiagSortByCount:
            {
                std::sort(diagDataVector.begin(), diagDataVector.end(),
                          descendingCountSort);
                break;
            }

            case kSTAFDiagSortBySource:
            {
                // Sort by Count since source will not be in the result

                std::sort(diagDataVector.begin(), diagDataVector.end(),
                          descendingCountSort);
                break;
            }
             
            default: break;
        }

        // Create a marshalled map containing diagnostics info for
        // all the triggers
        
        mc->setMapClassDefinition(fTriggersInfoClass->reference());
        mc->setMapClassDefinition(fTriggerCountClass->reference());

        STAFObjectPtr triggersInfoMap = fTriggersInfoClass->createInstance();

        if (startTime != sNotApplicable)
            triggersInfoMap->put("fromTimestamp", startTime);

        triggersInfoMap->put("toTimestamp", stopTime);

        if (elapsedTime != sNotApplicable)
            triggersInfoMap->put("elapsedTime", elapsedTime);
        
        // Iterate thru the sorted diagDataVector and generate the result

        DiagDataVector::iterator vIter;
        STAFObjectPtr outputList = STAFObject::createList();
        
        for (vIter = diagDataVector.begin(); vIter != diagDataVector.end();
             vIter++)
        {
            STAFObjectPtr triggerCountMap =
                fTriggerCountClass->createInstance();
            triggerCountMap->put("count", STAFString(vIter->count));
            triggerCountMap->put("trigger", vIter->trigger);

            // Add remaining map entries here
            outputList->append(triggerCountMap);

            triggerCount++;
        }

        triggersInfoMap->put("triggerList", outputList);
        triggersInfoMap->put("numberOfTriggers", STAFString(triggerCount));

        // Set the root object for the marshalled context and assign the marshalled output     
        mc->setRootObject(triggersInfoMap);
    }
    else if (parsedResult->optionTimes("SOURCES") != 0)
    {
        // List all the sources

        unsigned int sourceCount = 0;
        STAFDiagManager::DiagMap sourceMap;
        STAFDiagManager::DiagMap::iterator mIter;
       
        // Create a map of unique sources, accumulating counts by source

        for (mIter = diagMap.begin(); mIter != diagMap.end(); mIter++)
        {
            if (sourceMap.find(mIter->second.source.toLowerCase()) ==
                sourceMap.end())
            {
                sourceMap[mIter->second.source.toLowerCase()] =
                    mIter->second;
            }
            else
            {
                sourceMap[mIter->second.source.toLowerCase()].count +=
                    mIter->second.count;
            }
        }
        
        // Iterate thru the SourceMap and create a vector of sources

        DiagDataVector diagDataVector;
       
        for (mIter = sourceMap.begin(); mIter != sourceMap.end(); mIter++)
        {
            diagDataVector.push_back(mIter->second);
        }

        // Sort the diagDataVector (already sorted by trigger)

        switch (sortBy)
        {
            case kSTAFDiagSortByCount:
            {
                std::sort(diagDataVector.begin(), diagDataVector.end(),
                          descendingCountSort);
                break;
            }

            case kSTAFDiagSortBySource:
            {
                std::sort(diagDataVector.begin(), diagDataVector.end(),
                          AscendingSourceSort());
                break;
            }

            case kSTAFDiagSortByTrigger:
            {
                // Sort by Count since trigger will not be in the result

                std::sort(diagDataVector.begin(), diagDataVector.end(),
                          descendingCountSort);
                break;
            }

            default: break;
        }

        // Create a marshalled map containing diagnostics info for
        // all the sources
        
        mc->setMapClassDefinition(fSourcesInfoClass->reference());
        mc->setMapClassDefinition(fSourceCountClass->reference());

        STAFObjectPtr sourcesInfoMap = fSourcesInfoClass->createInstance();

        if (startTime != sNotApplicable)
            sourcesInfoMap->put("fromTimestamp", startTime);

        sourcesInfoMap->put("toTimestamp", stopTime);

        if (elapsedTime != sNotApplicable)
            sourcesInfoMap->put("elapsedTime", elapsedTime);

        // Iterate thru the sorted diagDataVector and generate the result

        DiagDataVector::iterator vIter;
        STAFObjectPtr outputList = STAFObject::createList();
        
        for (vIter = diagDataVector.begin(); vIter != diagDataVector.end();
             vIter++)
        {
            STAFObjectPtr sourceCountMap =
                fSourceCountClass->createInstance();
            sourceCountMap->put("count", STAFString(vIter->count));
            sourceCountMap->put("source", vIter->source);

            outputList->append(sourceCountMap);
            sourceCount++;
        }

        sourcesInfoMap->put("sourceList", outputList);
        sourcesInfoMap->put("numberOfSources", STAFString(sourceCount));

        mc->setRootObject(sourcesInfoMap);
    }
    else
    {
        // List all diagnostic data

        STAFStringList triggerList;
        STAFStringList sourceList;
        DiagDataVector diagDataVector;
        STAFDiagManager::DiagMap::iterator mIter;
       
        for (mIter = diagMap.begin(); mIter != diagMap.end(); mIter++)
        {
            diagDataVector.push_back(mIter->second);

            // Generate a list of all unique triggers

            if (triggerList.find(mIter->second.trigger.toLowerCase()) ==
                triggerList.end())
            {
                triggerList.insert(mIter->second.trigger.toLowerCase());
            }

            // Generate a list of all unique sources

            if (sourceList.find(mIter->second.source.toLowerCase()) ==
                sourceList.end())
            {
                sourceList.insert(mIter->second.source.toLowerCase());
            }
        }

        // Sort the diagDataVector (already sorted by trigger)

        switch (sortBy)
        {
            case kSTAFDiagSortByCount:
            {
                std::sort(diagDataVector.begin(), diagDataVector.end(),
                          descendingCountSort);
                break;
            }

            case kSTAFDiagSortBySource:
            {
                std::sort(diagDataVector.begin(), diagDataVector.end(),
                          AscendingSourceSort());
                break;
            }
             
            default: break;
        }

        // Create a marshalled map containing all diagnostics info

        mc->setMapClassDefinition(fAllDiagInfoClass->reference());
        mc->setMapClassDefinition(fComboCountClass->reference());

        STAFObjectPtr allInfoMap = fAllDiagInfoClass->createInstance();

        if (startTime != sNotApplicable)
            allInfoMap->put("fromTimestamp", startTime);

        allInfoMap->put("toTimestamp", stopTime);

        if (elapsedTime != sNotApplicable)
            allInfoMap->put("elapsedTime", elapsedTime);

        allInfoMap->put("numberOfTriggers", STAFString(triggerList.size()));
        allInfoMap->put("numberOfSources", STAFString(sourceList.size()));
        
        // Iterate thru the sorted diagDataVector and generate the result

        DiagDataVector::iterator vIter;
        STAFObjectPtr outputList = STAFObject::createList();
        
        for (vIter = diagDataVector.begin(); vIter != diagDataVector.end();
             vIter++)
        {
            STAFObjectPtr comboCountMap = fComboCountClass->createInstance();
            comboCountMap->put("count", STAFString(vIter->count));
            comboCountMap->put("trigger", vIter->trigger);
            comboCountMap->put("source", vIter->source);

            outputList->append(comboCountMap);
        }

        allInfoMap->put("comboList", outputList);

        mc->setRootObject(allInfoMap);
    }
    
    return STAFServiceResult(kSTAFOk, mc->marshall());
}


STAFServiceResult STAFDiagService::handleReset(
    const STAFServiceRequest &requestInfo)
{
    // Verify that the requesting machine/user has at least trust level 4

    IVALIDATE_TRUST(4, "RESET");
 
    // Parse the request

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

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

    return STAFServiceResult(gDiagManagerPtr->reset());
}


STAFServiceResult STAFDiagService::handleEnable(
    const STAFServiceRequest &requestInfo)
{
    // Verify that the requesting machine/user has at least trust level 4

    IVALIDATE_TRUST(4, "ENABLE");

    // Parse the request

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

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

    return STAFServiceResult(gDiagManagerPtr->enable());
}


STAFServiceResult STAFDiagService::handleDisable(
    const STAFServiceRequest &requestInfo)
{
    // Verify that the requesting machine/user has at least trust level 4

    IVALIDATE_TRUST(4, "DISABLE");
    
    // Parse the request

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

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

    return STAFServiceResult(gDiagManagerPtr->disable());
}


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

    IVALIDATE_TRUST(1, "HELP");

    STAFString result("DIAG service help" + *gLineSeparatorPtr +
                      *gLineSeparatorPtr);

    result += "RECORD TRIGGER <Trigger> SOURCE <Source>" +
              *gLineSeparatorPtr +
              "LIST   < [TRIGGER <Trigger> | SOURCE <Source> | " +
              "TRIGGERS | SOURCES]" +
              *gLineSeparatorPtr +
              "         [SORTBYCOUNT | SORTBYTRIGGER | SORTBYSOURCE] > |" +
              *gLineSeparatorPtr +
              "       SETTINGS" + *gLineSeparatorPtr +
              "RESET  FORCE" + *gLineSeparatorPtr +
              "ENABLE"  + *gLineSeparatorPtr +
              "DISABLE" + *gLineSeparatorPtr +
              "HELP"    + *gLineSeparatorPtr;

    return STAFServiceResult(kSTAFOk, result);
}