stafmonitorservice.cpp

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

        pData->fSetParser->addOption("MAXRECORDSIZE",    1,
                                     STAFCommandParser::kValueRequired);
        pData->fSetParser->addOption("ENABLERESOLVEMESSAGEVAR",    1,
                                     STAFCommandParser::kValueNotAllowed);
        pData->fSetParser->addOption("DISABLERESOLVEMESSAGEVAR",      1,
                                     STAFCommandParser::kValueNotAllowed);
        pData->fSetParser->addOptionGroup(
                        "ENABLERESOLVEMESSAGEVAR DISABLERESOLVEMESSAGEVAR",
                        0, 1);

        // PARMS        
        STAFCommandParseResultPtr parsedParmsResult =
            pData->fSetParser->parse(pInfo->parms);

        if (parsedParmsResult->rc != kSTAFOk) 
        {
            return parsedParmsResult->rc;
        }
        
        if (parsedParmsResult->optionTimes(sResolveMessage))
        {
            pData->fResolveMessage = 1;
        }

        if (parsedParmsResult->optionTimes(sNoResolveMessage))
        {
            pData->fResolveMessage = 0;
        }
        
        if (parsedParmsResult->optionTimes(sMaxRecordSize))
        {
            STAFResultPtr maxResult = resolveOpLocal(pData, parsedParmsResult,
                                                     sMaxRecordSize);

            if (maxResult->rc != kSTAFOk)
            {
                *pErrorBuffer = maxResult->result.adoptImpl();
                return maxResult->rc;
            }

            if (!maxResult->result.isDigits())
            {
                STAFString error(
                    "MAXRECORDSIZE value (" + maxResult->result +
                    ") is not an integer");
                *pErrorBuffer = error.adoptImpl();
                return kSTAFServiceConfigurationError;
            }

            pData->fMaxRecordSize = maxResult->result.asUInt();
        }        
        
        if (parsedParmsResult->optionTimes(sEnableResolveMessageVar))
        {
            pData->fEnableResolveMessageVar = 1;
        }

        if (parsedParmsResult->optionTimes(sDisableResolveMessageVar))
        {
            pData->fEnableResolveMessageVar = 0;
        }

        // Construct map class for the marshalling LIST SETTINGS output

        pData->fSettingsClass = STAFMapClassDefinition::create(
            "STAF/Service/Monitor/Settings");

        pData->fSettingsClass->addKey("maxRecordSize", "Max Record Size");
        pData->fSettingsClass->addKey("resolveMessage", "Resolve Message");
        pData->fSettingsClass->addKey("resolveMessageVar",
                                      "Resolve Message Var");
        
        // Construct map class for handle information

        pData->fHandleInfoClass = STAFMapClassDefinition::create(
            "STAF/Service/Monitor/HandleInfo");

        pData->fHandleInfoClass->addKey("handle",    "Handle");
        pData->fHandleInfoClass->addKey("timestamp", "Date-Time");
        pData->fHandleInfoClass->addKey("size"     , "Size");

        // Construct map class for name information

        pData->fNameInfoClass = STAFMapClassDefinition::create(
            "STAF/Service/Monitor/NameInfo");

        pData->fNameInfoClass->addKey("name",    "Name");
        pData->fNameInfoClass->addKey("timestamp", "Date-Time");
        pData->fNameInfoClass->addKey("size"     , "Size");
        
        // Construct map class for monitor information

        pData->fMonitorInfoClass = STAFMapClassDefinition::create(
            "STAF/Service/Monitor/MonitorInfo");

        pData->fMonitorInfoClass->addKey("timestamp", "Date-Time");
        pData->fMonitorInfoClass->addKey("message", "Message");

        // Get the line separator

        STAFResultPtr result = pData->fHandlePtr->submit(
            "local", "VAR", "RESOLVE REQUEST STRING {STAF/Config/Sep/Line}");

        if (result->rc != kSTAFOk)
        {
            *pErrorBuffer = result->result.adoptImpl();
            return result->rc;
        }

        lineSep = result->result;

         // Get the machine name for the local machine

        result = pData->fHandlePtr->submit(
            sLocal, sVar, "RESOLVE REQUEST STRING {STAF/Config/Machine}");

        if (result->rc != kSTAFOk)
        {
            *pErrorBuffer = result->result.adoptImpl();
            return result->rc;
        }

        pData->fLocalMachineName = result->result;

        // Assign the invalid directory mesasge

        STAFString invalidDirMessage("The STAF/Service/");

        invalidDirMessage += pData->fShortName;
        invalidDirMessage += "/Directory variable in the STAF configuration "
                             "file is invalid";
    }
    catch (STAFException &e)
    { 
        *pErrorBuffer = getExceptionString(e,
                        "STAFMonitorService.cpp: STAFServiceInit").adoptImpl();
    }
    catch (...)
    {
        STAFString error(
                    "STAFMonitorService.cpp: STAFServiceInit: Caught unknown "
                    "exception in STAFServiceAcceptRequest()");
        *pErrorBuffer = error.adoptImpl();
    }    

    return retCode;
}


STAFRC_t STAFServiceAcceptRequest(STAFServiceHandle_t serviceHandle,
                                  void *pRequestInfo, unsigned int reqLevel,
                                  STAFString_t *pResultBuffer)
{
    if (reqLevel != 30) return kSTAFInvalidAPILevel;

    STAFRC_t retCode = kSTAFUnknownError;

    try
    {
        STAFResultPtr result(new STAFResult(kSTAFOk, STAFString()),
                             STAFResultPtr::INIT);        

        STAFServiceRequestLevel30 *pInfo =
            reinterpret_cast<STAFServiceRequestLevel30 *>(pRequestInfo);

        MonitorServiceData *pData =
            reinterpret_cast<MonitorServiceData *>(serviceHandle);

        STAFString request(pInfo->request);
        STAFString action = request.subWord(0, 1).toLowerCase();
        
        //call functions for the request
        if (action == "log")
            result = handleLog(pInfo, pData);
        else if (action == "query")
            result = handleQuery(pInfo, pData);
        else if (action == "list")
            result = handleList(pInfo, pData);
        else if (action == "delete")
            result = handleDelete(pInfo, pData);
        else if (action == "set")
            result = handleSet(pInfo, pData);
        else if (action == "help")
            result = handleHelp(pInfo, pData);
         else if (action == "version")
            result = handleVersion(pInfo, pData);
        else
            result = STAFResultPtr(new STAFResult(kSTAFInvalidRequestString,
                                   request.subWord(0, 1)), 
                                   STAFResultPtr::INIT);

        *pResultBuffer = result->result.adoptImpl();
        retCode = result->rc;
    }
    catch (STAFException &e)
    { 
        *pResultBuffer = getExceptionString(e,
                         "STAFMonitorService.cpp: "
                         "STAFServiceAcceptRequest").adoptImpl();
    }
    catch (...)
    {
        STAFString error(
                    "STAFMonitorService.cpp: STAFServiceAcceptRequest: Caught "
                    "unknown exception in STAFServiceAcceptRequest()");
        *pResultBuffer = error.adoptImpl();
    }

    return retCode;
}


STAFRC_t STAFServiceTerm(STAFServiceHandle_t serviceHandle,
                         void *pTermInfo, unsigned int termLevel,
                         STAFString_t *pErrorBuffer)
{
    if (termLevel != 0) return kSTAFInvalidAPILevel;

    STAFRC_t retCode = kSTAFUnknownError;

    try
    {
        retCode = kSTAFOk;

        MonitorServiceData *pData = 
            reinterpret_cast<MonitorServiceData *>(serviceHandle);

        // Un-register Help Data (if add any service-specific error codes)

    }
    catch (STAFException &e)
    { 
        *pErrorBuffer = getExceptionString(e,
                        "STAFMonitorSerice.cpp: STAFServiceTerm").adoptImpl();
    }
    catch (...)
    {
        STAFString error(
                    "STAFMonitorService.cpp: STAFServiceTerm: Caught unknown "
                    "exception in STAFServiceAcceptRequest()");
        *pErrorBuffer = error.adoptImpl();
    }

    return retCode;
}


STAFRC_t STAFServiceDestruct(STAFServiceHandle_t *serviceHandle,
                             void *pDestructInfo, unsigned int destructLevel,
                             STAFString_t *pErrorBuffer)
{
    if (destructLevel != 0) return kSTAFInvalidAPILevel;

    STAFRC_t retCode = kSTAFUnknownError;

    try
    {
        MonitorServiceData *pData =
            reinterpret_cast<MonitorServiceData *>(*serviceHandle);

        delete pData;
        *serviceHandle = 0;

        retCode = kSTAFOk;
    }
    catch (STAFException &e)
    { 
        *pErrorBuffer = getExceptionString(e,
                    "STAFMonitorSerice.cpp: STAFServiceDestruct").adoptImpl();
    }
    catch (...)
    {
        STAFString error(
                    "STAFMonitorService.cpp: STAFServiceDestruct: Caught "
                    "unknown exception in STAFServiceAcceptRequest()");
        *pErrorBuffer = error.adoptImpl();
    }

    return retCode;
}


STAFResultPtr handleLog(STAFServiceRequestLevel30 *pInfo, 
                        MonitorServiceData *pData)
{
    // Verify the requesting machine/user has at least trust level 3

    VALIDATE_TRUST(3, pData->fShortName, "LOG", pData->fLocalMachineName);

    // Parse the request

    STAFCommandParseResultPtr parsedResult = pData->fLogParser->parse(
        pInfo->request);

    if (parsedResult->rc != kSTAFOk)
    {
        return STAFResultPtr(new STAFResult(kSTAFInvalidRequestString,
                             parsedResult->errorBuffer), STAFResultPtr::INIT);
    }

    STAFString fMessage = STAFTimestamp::now().asString() + sSpace;

    // Determine if we need to resolve the message
    // Start with the PARMS/SET resolve value        
    unsigned int resolveMessage = pData->fResolveMessage;

    if ((parsedResult->optionTimes(sNoResolveMessage)) ||
        (parsedResult->optionTimes(sResolveMessage))) 
    {
        // Request contains [NO]RESOLVEMESSAGE, so use its resolve value
        if (parsedResult->optionTimes(sNoResolveMessage))
            resolveMessage = 0;
        else
            resolveMessage = 1;
    }
    else if (pData->fEnableResolveMessageVar)
    {                 
        // Check the STAF/Service/<Monitor-Name>/ResolveMessage variable
        STAFString varReq = "{STAF/Service/";
        varReq += pData->fShortName;
        varReq += "/ResolveMessage}";        
        
        STAFResultPtr varResult = resolveStr(pInfo, pData, varReq);
        if (varResult->rc == kSTAFOk) 
        {
            // Variable was found, so use its resolve value
            if (!varResult->result.isDigits())
            {
                return STAFResultPtr(new STAFResult(kSTAFInvalidValue, 
                                     STAFString()), STAFResultPtr::INIT);