stafmonitorservice.cpp

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

            
            if ((machineIterator = pData->fMap.find(listMachine.toUpperCase()))
                != pData->fMap.end())
            {
                NameMap::iterator nameIterator;

                for(nameIterator = machineIterator->second.nameMap.begin();
                    nameIterator != machineIterator->second.nameMap.end();
                    ++nameIterator)
                {
                    STAFObjectPtr nameInfoMap =
                        pData->fNameInfoClass->createInstance();

                    nameInfoMap->put("name",
                        nameIterator->second.originalCaseName);
                    nameInfoMap->put("timestamp",
                        nameIterator->second.message.subString(0,17));
                    nameInfoMap->put("size",
                        STAFString(nameIterator->second.message.length()));

                    nameList->append(nameInfoMap);
                }
            }

            mc->setRootObject(nameList);
        }
        else
        {
            // Set the map class definitions for the marshalling context

            mc->setMapClassDefinition(pData->fHandleInfoClass->reference());

            // Create a empty list object for the marshalled list of handles
            // for the specified machine

            STAFObjectPtr handleList = STAFObject::createList();
            
            if ((machineIterator = pData->fMap.find(listMachine.toUpperCase()))
                != pData->fMap.end())
            {
                HandleMap::iterator handleIterator;

                for(handleIterator = machineIterator->second.handleMap.begin();
                    handleIterator != machineIterator->second.handleMap.end();
                    ++handleIterator)
                {
                    STAFObjectPtr handleInfoMap =
                        pData->fHandleInfoClass->createInstance();

                    handleInfoMap->put("handle", handleIterator->first);
                    handleInfoMap->put("timestamp",
                                       handleIterator->second.subString(0,17));
                    handleInfoMap->put("size",
                                   STAFString(handleIterator->second.length()));

                    handleList->append(handleInfoMap);
                }
            }

            mc->setRootObject(handleList);
        }
    }

    return STAFResultPtr(new STAFResult(kSTAFOk, mc->marshall()), 
                         STAFResultPtr::INIT);
}


STAFResultPtr handleDelete(STAFServiceRequestLevel30 *pInfo, 
                           MonitorServiceData *pData)
{
    STAFString result;
    STAFRC_t rc = kSTAFOk;

    // Verify the requesting machine/user has at least trust level 4

    VALIDATE_TRUST(4, pData->fShortName, "DELETE", pData->fLocalMachineName);

    // Parse the request

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

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

    if (pData->fMap.begin() == pData->fMap.end())
    {
        result = "There are no entries in the Monitor Log." + lineSep;
        return STAFResultPtr(new STAFResult(kSTAFOk, result),
                             STAFResultPtr::INIT);
    } 
    else if (parsedResult->optionTimes(sBefore) != 0)
    {        
        MachineMap::iterator machineIterator;
        HandleMap::iterator handleIterator;        
        STAFMutexSemLock lock(*pData->fMapSem);
        STAFString beforeDateString = parsedResult->optionValue(sBefore);                                
        
        try
        {
            if (beforeDateString.isEqualTo(sToday, kSTAFStringCaseInsensitive))
            {   
                beforeDateString = 
                    (STAFTimestamp::now().asString()).subString(0,8);
            }
           
            STAFTimestamp beforeTimeStamp = STAFTimestamp(beforeDateString);            
           
            for(machineIterator = pData->fMap.begin();
                machineIterator != pData->fMap.end(); ++machineIterator)
            {
                for(handleIterator = machineIterator->second.handleMap.begin();
                    handleIterator != machineIterator->second.handleMap.end();
                    )                
                {                      
                    if (STAFTimestamp(handleIterator->second.subString(0,8)) <
                            beforeTimeStamp)
                     machineIterator->second.handleMap.erase(handleIterator++);
                    else                 
                        handleIterator++;                
                }
            }
        }
        catch(STAFTimestampInvalidDateException &e)
        {
            result = "Invalid Date format.  YYYYMMDD, MM/DD/YY, or ";
            result += "MM/DD/YYYY" + lineSep;
            result += getExceptionString(e) + lineSep;
            return STAFResultPtr(new STAFResult(kSTAFInvalidValue,
                                 result), STAFResultPtr::INIT);
        }        
        catch (STAFException &e)
        { 
            result = getExceptionString(e,
                    "STAFMonitorSerice.cpp: Delete ").adoptImpl();
            return STAFResultPtr(new STAFResult(kSTAFInvalidRequestString,
                                 result), STAFResultPtr::INIT);                
        }
        catch (...)
        {
            result = "Unknown exception caught in STAFMonitorService ";            
            return STAFResultPtr(new STAFResult(kSTAFUnknownError,
                                 result), STAFResultPtr::INIT);
        }    
    }  
    else
    {
        pData->fMap.clear();
    }
  
    return STAFResultPtr(new STAFResult(kSTAFOk, STAFString()),
                         STAFResultPtr::INIT);
}


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

    VALIDATE_TRUST(5, pData->fShortName, "SET", pData->fLocalMachineName);

    // Parse the request

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

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

    if (parsedResult->optionTimes(sMaxRecordSize) != 0)
    {          
        STAFResultPtr maxResult = resolveOp(pInfo, pData, parsedResult,
                                            sMaxRecordSize);

        if (maxResult->rc != kSTAFOk) return maxResult;

        if (!maxResult->result.isDigits())
        {
            maxResult->rc = kSTAFInvalidValue;
            return maxResult;
        }

        pData->fMaxRecordSize = maxResult->result.asUInt();
    }
    
    if (parsedResult->optionTimes(sResolveMessage) != 0)
    {
        pData->fResolveMessage = 1;
    }
    else if (parsedResult->optionTimes(sNoResolveMessage) != 0)
    {
        pData->fResolveMessage = 0;
    }

    if (parsedResult->optionTimes(sEnableResolveMessageVar) != 0)
    {
        pData->fEnableResolveMessageVar = 1;
    }
    else if (parsedResult->optionTimes(sDisableResolveMessageVar) != 0)
    {
        pData->fEnableResolveMessageVar = 0;
    }    
    
    return STAFResultPtr(new STAFResult(kSTAFOk, ""), STAFResultPtr::INIT);
}


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

    VALIDATE_TRUST(1, pData->fShortName, "HELP", pData->fLocalMachineName);

    // Return the help text

    STAFString help("MONITOR Service Help" + lineSep + lineSep);        

    help += "LOG     MESSAGE <Message> [NAME <Name>] [RESOLVEMESSAGE | NORESOLVEMESSAGE]" ;
    help += lineSep;
    help += "QUERY   MACHINE <Machine> < HANDLE <Handle> | NAME <Name> >";
    help += lineSep;
    help += "LIST    <MACHINES | MACHINE <Machine> [NAMES] | SETTINGS>";
    help += lineSep;
    help += "DELETE  [BEFORE <Timestamp>] CONFIRM";
    help += lineSep;
    help += "SET     [RESOLVEMESSAGE | NORESOLVEMESSAGE]";
    help += lineSep;
    help += "        [MAXRECORDSIZE <Size>]";
    help += lineSep;
    help += "        [ENABLERESOLVEMESSAGEVAR | DISABLERESOLVEMESSAGEVAR] ";
    help += lineSep;
    help += "VERSION" + lineSep;
    help += "HELP" + lineSep;

    return STAFResultPtr(new STAFResult(kSTAFOk, help), STAFResultPtr::INIT);
}


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

    VALIDATE_TRUST(1, pData->fShortName, "VERSION", pData->fLocalMachineName);

    return STAFResultPtr(new STAFResult(kSTAFOk, monitorVersion), 
                         STAFResultPtr::INIT);
}


STAFResultPtr resolveStr(STAFServiceRequestLevel30 *pInfo,
                         MonitorServiceData *pData, 
                         const STAFString &theString)
{
    return pData->fHandlePtr->submit(sLocal, sVar, sResStrResolve +
                                     STAFString(pInfo->requestNumber) +
                                     sString +
                                     pData->fHandlePtr->wrapData(theString));
}


STAFResultPtr resolveOp(STAFServiceRequestLevel30 *pInfo, 
                        MonitorServiceData *pData,
                        STAFCommandParseResultPtr &parsedResult,
                        const STAFString &fOption, unsigned int optionIndex)
{
    // ???: Would const STAFString & work here?
    STAFString optionValue = parsedResult->optionValue(fOption, optionIndex);

    if (optionValue.find(sLeftCurlyBrace) == STAFString::kNPos)
    {
        return STAFResultPtr(new STAFResult(kSTAFOk, optionValue),
                             STAFResultPtr::INIT);
    }

    return resolveStr(pInfo, pData, optionValue);
}


STAFResultPtr resolveOpLocal(MonitorServiceData *pData,
                             STAFCommandParseResultPtr &parsedResult,
                             const STAFString &fOption,
                             unsigned int optionIndex)
{
    // ???: Would const STAFString & work here?
    STAFString optionValue = parsedResult->optionValue(fOption, optionIndex);

    if (optionValue.find(sLeftCurly) == STAFString::kNPos)
    {
        return STAFResultPtr(new STAFResult(kSTAFOk, optionValue),
                             STAFResultPtr::INIT);
    }

    return pData->fHandlePtr->submit(sLocal, sVar, sResStrResolve +
                                      sString +
                                      pData->fHandlePtr->wrapData(optionValue));
}


void registerHelpData(MonitorServiceData *pData, unsigned int errorNumber,
                      const STAFString &shortInfo, const STAFString &longInfo)
{
    static STAFString regString("REGISTER SERVICE %C ERROR %d INFO %C "
                                "DESCRIPTION %C");

    pData->fHandlePtr->submit(sLocal, sHelp, STAFHandle::formatString(
        regString.getImpl(), pData->fShortName.getImpl(), errorNumber,
        shortInfo.getImpl(), longInfo.getImpl()));
}


void unregisterHelpData(MonitorServiceData *pData, unsigned int errorNumber)
{
    static STAFString regString("UNREGISTER SERVICE %C ERROR %d");

    pData->fHandlePtr->submit(sLocal, sHelp, STAFHandle::formatString(
        regString.getImpl(), pData->fShortName.getImpl(), errorNumber));
}