staftraceservice.cpp

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

/*****************************************************************************/
/* Software Testing Automation Framework (STAF)                              */
/* (C) Copyright IBM Corp. 2004, 2005                                        */
/*                                                                           */
/* This software is licensed under the Common Public License (CPL) V1.0.     */
/*****************************************************************************/

#include "STAF.h"
#include "STAFProc.h"
#include "STAFProcUtil.h"
#include "STAFUtil.h"
#include "STAFTrace.h"
#include "STAFServiceManager.h"
#include "STAFTraceService.h"
#include "STAFThreadManager.h"

static const int kColonColumn = 21;
static const STAFString kEnabledString = "Enabled";
static const STAFString kDisabledString = "Disabled";
STAFTraceService::STAFTracepointMap
        STAFTraceService::kSTAFTracepointMap =
        STAFTraceService::fillSTAFTracepointMap();
STAFTraceService::STAFTracepointNameMap
        STAFTraceService::kSTAFTracepointNameMap =
        STAFTraceService::fillSTAFTracepointNameMap();


STAFTraceService::STAFTraceService() : STAFService("Trace")
{
    // enable|disable options
    fEnableDisableParser.addOption("ENABLE", 1,
        STAFCommandParser::kValueNotAllowed);
    fEnableDisableParser.addOption("DISABLE", 1,
        STAFCommandParser::kValueNotAllowed);
    fEnableDisableParser.addOption("ALL", 1,
        STAFCommandParser::kValueNotAllowed);
    fEnableDisableParser.addOption("TRACEPOINTS", 1,
        STAFCommandParser::kValueAllowed);
    fEnableDisableParser.addOption("TRACEPOINT", 0,
        STAFCommandParser::kValueRequired);
    fEnableDisableParser.addOption("SERVICES", 1,
        STAFCommandParser::kValueAllowed);
    fEnableDisableParser.addOption("SERVICE", 0,
        STAFCommandParser::kValueRequired);

    // enable|disable groups
    fEnableDisableParser.addOptionGroup("ENABLE DISABLE", 1, 1);

    // enable|disable needs
    fEnableDisableParser.addOptionNeed("ENABLE DISABLE",
        "ALL TRACEPOINT SERVICE TRACEPOINTS SERVICES");

    //SET options
    fSetParser.addOption("SET", 1,
        STAFCommandParser::kValueNotAllowed);
    fSetParser.addOption("DESTINATION", 1,
        STAFCommandParser::kValueNotAllowed);
    fSetParser.addOption("TO", 1,
        STAFCommandParser::kValueNotAllowed);
    fSetParser.addOption("STDOUT", 1,
        STAFCommandParser::kValueNotAllowed);
    fSetParser.addOption("STDERR", 1,
        STAFCommandParser::kValueNotAllowed);
    fSetParser.addOption("FILE", 1,
        STAFCommandParser::kValueRequired);
    fSetParser.addOption("DEFAULTSERVICESTATE", 1,
        STAFCommandParser::kValueRequired);


    //SET groups
    fSetParser.addOptionGroup("STDOUT STDERR FILE", 0, 1);
    fSetParser.addOptionGroup("DEFAULTSERVICESTATE DESTINATION", 1, 1);

    //SET needs
    fSetParser.addOptionNeed("SET", "TO DEFAULTSERVICESTATE");
    fSetParser.addOptionNeed("DESTINATION", "SET");
    fSetParser.addOptionNeed("TO", "DESTINATION");
    fSetParser.addOptionNeed("TO", "STDOUT STDERR FILE");
    fSetParser.addOptionNeed("STDOUT STDERR FILE DEFAULTSERVICESTATE", "SET");


    //LIST options
    fListParser.addOption("LIST", 1,
        STAFCommandParser::kValueNotAllowed);
    fListParser.addOption("SETTINGS", 1,
        STAFCommandParser::kValueNotAllowed);

    //LIST groups
    fListParser.addOptionGroup("LIST", 1, 1);
    fListParser.addOptionGroup("SETTINGS", 0, 1);

    //LIST needs
    fListParser.addOptionNeed("SETTINGS", "LIST");

    // Construct map class for a trace info

    fTraceInfoClass = STAFMapClassDefinition::create(
        "STAF/Service/Trace/TraceInfo");
    fTraceInfoClass->addKey("tracingTo", "Tracing To");
    fTraceInfoClass->addKey("defaultServiceState", "Default Service State");
    fTraceInfoClass->addKey("tracePoints", "Trace Points");
    fTraceInfoClass->addKey("services", "Services");

    // Construct map class for a tracepoint states

    fTracepointClass = STAFMapClassDefinition::create(
        "STAF/Service/Trace/Tracepoint");
    fTracepointClass->addKey("INFO", STAFString("Info"));
    fTracepointClass->addKey("WARNING", STAFString("Warning"));
    fTracepointClass->addKey("ERROR", STAFString("Error"));
    fTracepointClass->addKey("SERVICEREQUEST", STAFString("ServiceRequest"));
    fTracepointClass->addKey("SERVICERESULT", STAFString("ServiceResult"));
    fTracepointClass->addKey("SERVICEERROR", STAFString("ServiceError"));
    fTracepointClass->addKey("SERVICEACCESSDENIED",
                             STAFString("ServiceAccessDenied"));
    //fTracepointClass->addKey("serviceManagement",
    //                         STAFString("ServiceManagement"));
    fTracepointClass->addKey("REMOTEREQUESTS", STAFString("RemoteRequests"));
    fTracepointClass->addKey("REGISTRATION", STAFString("Registration"));
    fTracepointClass->addKey("DEPRECATED", STAFString("Deprecated"));
    fTracepointClass->addKey("DEBUG", STAFString("Debug"));
    fTracepointClass->addKey("SERVICECOMPLETE", STAFString("ServiceComplete"));
}


STAFServiceResult STAFTraceService::acceptRequest(
    const STAFServiceRequest &requestInfo)
{
    STAFString action = requestInfo.fRequest.subWord(0, 1).lowerCase();

    if ((action == "enable") | (action == "disable"))
            return handleEnableDisable(requestInfo);
    else if (action == "set")   return handleSet(requestInfo);
    else if (action == "list")  return handleList(requestInfo);
    else if (action == "purge") return handlePurge(requestInfo);
    else if (action == "help")    return handleHelp(requestInfo);
    else return kSTAFInvalidRequestString;
}

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

    IVALIDATE_TRUST(2, "LIST");

    // Parse the request

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

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

    STAFString errorBuffer;
    STAFString traceFilename;
    STAFTraceDestination_t traceDestination = 
        STAFTrace::getTraceDestination(traceFilename);
    
    // Create a marshalled map containing the trace information.
    // It will contain a map of the tracepoints and their trace states and
    // a map of the services and their trace states.

    STAFObjectPtr mc = STAFObject::createMarshallingContext();
    mc->setMapClassDefinition(fTraceInfoClass->reference());
    mc->setMapClassDefinition(fTracepointClass->reference());
    
    STAFObjectPtr traceInfoMap = fTraceInfoClass->createInstance();

    if (traceDestination == kSTAFTraceToStdout)
        traceInfoMap->put("tracingTo", STAFString("Stdout"));
    else if (traceDestination == kSTAFTraceToStderr)
        traceInfoMap->put("tracingTo", STAFString("Stderr"));
    else if (traceDestination == kSTAFTraceToFile)
        traceInfoMap->put("tracingTo", traceFilename);
    
    if (STAFServiceManager::getDefaultTraceState() == 
        STAFServiceManager::kTraceEnabled)
        traceInfoMap->put("defaultServiceState", STAFString("Enabled"));
    else
        traceInfoMap->put("defaultServiceState", STAFString("Disabled"));

    STAFObjectPtr tracepointMap = fTracepointClass->createInstance();

    STAFTraceService::STAFTracepointMap::iterator tracepointMapIter;

    for (tracepointMapIter = kSTAFTracepointMap.begin();
         tracepointMapIter != kSTAFTracepointMap.end(); tracepointMapIter++)
    {
        if (STAFTrace::doTrace(tracepointMapIter->first))
            tracepointMap->put(tracepointMapIter->second, kEnabledString);
        else
            tracepointMap->put(tracepointMapIter->second, kDisabledString);
    }

    traceInfoMap->put("tracePoints", tracepointMap);
   
    // Construct map class for the service states.  Note that this map
    // class definition is dynamically generated based on the services in
    // the serviceTraceStatusList at the time of this request.

    fServiceClass = STAFMapClassDefinition::create(
        "STAF/Service/Trace/Service");
    mc->setMapClassDefinition(fServiceClass->reference());
    STAFObjectPtr serviceMap = fServiceClass->createInstance();

    STAFServiceManager::ServiceTraceStatusList serviceTraceStatusList =
        STAFServiceManager::getServiceTraceStatusList();
    STAFServiceManager::OrderedServiceList allServiceList =
         gServiceManagerPtr->getOrderedServiceListCopy();
    STAFServiceManager::ServiceTraceStatusList::iterator traceStatusIter;

    for (traceStatusIter = serviceTraceStatusList.begin();
         traceStatusIter != serviceTraceStatusList.end(); traceStatusIter++)
    {
        fServiceClass->addKey(STAFString(traceStatusIter->first),
                              STAFString(traceStatusIter->first));

        if (traceStatusIter->second == STAFServiceManager::kTraceEnabled)
        {
            if (allServiceList.find(traceStatusIter->first) ==
                allServiceList.end())
            {
                serviceMap->put(
                    STAFString(traceStatusIter->first),
                    kEnabledString + STAFString(" (Not registered)"));
            }
            else
            {
                serviceMap->put(
                    STAFString(traceStatusIter->first), kEnabledString);
            }
        }
        else if (allServiceList.find(traceStatusIter->first) ==
                 allServiceList.end())
        {
            serviceMap->put(
                STAFString(traceStatusIter->first),
                kDisabledString + STAFString(" (Not registered)"));
        }
        else
        {
            serviceMap->put(
                STAFString(traceStatusIter->first), kDisabledString);
        }
    }

    traceInfoMap->put("services", serviceMap);

    mc->setRootObject(traceInfoMap);

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

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

    IVALIDATE_TRUST(5, "SET");

    // Parse the request

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

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

    STAFString errorBuffer;
    DEFINE_VAR_POOL_LIST(varPoolList, varPoolListSize, requestInfo);
    STAFString filename;
    STAFString result;
    STAFRC_t rc = RESOLVE_OPTIONAL_STRING_OPTION("FILE", filename);

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

    if (parsedResult->optionTimes("DESTINATION") != 0)
    {
        // Set the trace destination
        if (parsedResult->optionTimes("STDOUT"))
            STAFTrace::setTraceDestination(kSTAFTraceToStdout);
        else if (parsedResult->optionTimes("STDERR"))
            STAFTrace::setTraceDestination(kSTAFTraceToStderr);
        else if (parsedResult->optionTimes("FILE"))
            STAFTrace::setTraceDestination(kSTAFTraceToFile, filename);