stafvariableservice.cpp

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

        // If request from local system,
        // Use local handle pool on the current handle number;
        // Else if request from remote system,
        // Use local system pool

        // XXX: May need to re-consider the exact behavior in this case.

        if (requestInfo.fIsLocalRequest)
        {
            // If this is a local system, use the handle's variable pool

            rc = gHandleManagerPtr->variablePool(requestInfo.fHandle, 
                                                 handleVarPoolPtr);

            if (rc != kSTAFOk) return STAFServiceResult(rc);

            varPoolListMain[varPoolListSizeMain] = handleVarPoolPtr;
            varPoolListSizeMain++;
        }
        else
        {
            // If this is a remote system, use the system pool
                
            varPoolListMain[varPoolListSizeMain] = 
                requestInfo.fLocalSystemVarPool;
            varPoolListSizeMain++;
        }
    }


    STAFString result;

    if (parsedResult->optionTimes("SET") != 0)
    {
        // Verify that the requesting machine/user has at least trust level 3

        IVALIDATE_TRUST(3, "SET");

        for (int i = 1; i <= parsedResult->optionTimes("VAR"); ++i)
        {
            STAFString nameAndValue = parsedResult->optionValue("VAR", i);
            unsigned int equalPos = nameAndValue.find(kUTF8_EQUAL);

            if (equalPos == STAFString::kNPos)
            {
                return STAFServiceResult(kSTAFInvalidRequestString, "");
            }

            // For SET command, there is only one pool involved
            ((STAFVariablePool*)varPoolListMain[0])->set(
                nameAndValue.subString(0, equalPos),
                nameAndValue.subString(equalPos +
                                       nameAndValue.sizeOfChar(equalPos)));
        }
    }
    else if (parsedResult->optionTimes("GET") != 0)
    {
        // Verify that the requesting machine/user has at least trust level 2

        IVALIDATE_TRUST(2, "GET");

        // For GET command, there is only one pool involved
        
        rc = varPoolListMain[0]->get(parsedResult->optionValue("VAR"), result);
    }
    else if (parsedResult->optionTimes("DELETE") != 0)
    {
        // Verify that the requesting machine/user has at least trust level 3

        IVALIDATE_TRUST(3, "DELETE");

        for (int i = 1; (i <= parsedResult->optionTimes("VAR")) && 
             (rc == kSTAFOk); ++i)
        {
            // For DELETE command, there is only one pool involved
            
            rc = ((STAFVariablePool*)varPoolListMain[0])->del(
                parsedResult->optionValue("VAR", i));
        }
    }
    else if (parsedResult->optionTimes("LIST") != 0)
    {
        // Verify that the requesting machine/user has at least trust level 2

        IVALIDATE_TRUST(2, "LIST");

        // We construct a result variable pool
        // based on variable pools we constructed before

        STAFVariablePoolPtr resultVarPoolPtr = STAFVariablePoolPtr(
            new STAFVariablePool, STAFVariablePoolPtr::INIT);

        for (int i = varPoolListSizeMain - 1; i >= 0; i--)
        {
            // Put values into result variable pool.
            // Variables in a pool earlier in the list
            // override variables in a pool later in the list

            STAFVariablePool::VariableMap theVarMap;

            theVarMap = ((STAFVariablePool*)varPoolListMain[i])->
                getVariableMapCopy();

            STAFVariablePool::VariableMap::iterator theIter;

            for (theIter = theVarMap.begin();
                 theIter != theVarMap.end(); theIter++)
            {
                const STAFVariablePool::Variable &var = theIter->second;

                resultVarPoolPtr->set(var.name, var.value);    
            }
        }            

        // Build the output based on the result variable pool

        STAFVariablePool::VariableMap theVarMap = 
            resultVarPoolPtr->getVariableMapCopy();

        STAFVariablePool::VariableMap::iterator theIter;
                                   
        // Construct map-class for listing variables - its keys will be
        // dynamically generated

        fVarInfoClass = STAFMapClassDefinition::create(
            "STAF/Service/Var/VarInfo");
                                   
        // Create a marshalled map to contain the STAF variables

        STAFObjectPtr mc = STAFObject::createMarshallingContext();
        mc->setMapClassDefinition(fVarInfoClass->reference());
        STAFObjectPtr varInfoMap = fVarInfoClass->createInstance();

        for (theIter = theVarMap.begin();
             theIter != theVarMap.end(); theIter++)
        {
            const STAFVariablePool::Variable &var = theIter->second;

            // Dynamically generate the map keys for the map class definition
            fVarInfoClass->addKey(STAFString(var.name), STAFString(var.name));

            varInfoMap->put(STAFString(var.name), STAFString(var.value));
        }        

        mc->setRootObject(varInfoMap);
        result = mc->marshall();
    }
    else if (parsedResult->optionTimes("RESOLVE") != 0)
    {
        // Verify that the requesting machine/user has at least trust level 3

        IVALIDATE_TRUST(3, "RESOLVE");

        unsigned int numTimes = parsedResult->optionTimes("STRING");

        if (numTimes == 1)
        {
            rc = STAFVariablePool::resolve(
                parsedResult->optionValue("STRING"), varPoolListMain,
                varPoolListSizeMain, result);
        }
        else
        {
            // Create a marshalled list of maps containing resolved variable
            // data

            STAFObjectPtr mc = STAFObject::createMarshallingContext();
            mc->setMapClassDefinition(fResolveStringClass->reference());
            STAFObjectPtr outputList = STAFObject::createList();

            for (int i = 1; i <= numTimes; ++i)
            {
                STAFObjectPtr resolveVarMap =
                    fResolveStringClass->createInstance();

                rc = STAFVariablePool::resolve(
                    parsedResult->optionValue("STRING", i), varPoolListMain,
                    varPoolListSizeMain, result);

                resolveVarMap->put("rc", STAFString(rc));
                resolveVarMap->put("result", result);

                outputList->append(resolveVarMap);
            }

            rc = kSTAFOk;

            mc->setRootObject(outputList);
            result = mc->marshall();
        }
    }
    else  // HELP
    {
        // Verify that the requesting machine/user has at least trust level 1

        IVALIDATE_TRUST(1, "HELP");

        result = "VAR Service Help" + *gLineSeparatorPtr + *gLineSeparatorPtr;
        result += "SET [SYSTEM | SHARED | HANDLE <Handle>] VAR <Name=Value> "
                  "[VAR <Name=Value>]..." + *gLineSeparatorPtr
                  + *gLineSeparatorPtr;
        result += "GET [SYSTEM | SHARED | HANDLE <Handle>] VAR <Name>" 
                  + *gLineSeparatorPtr + *gLineSeparatorPtr;
        result += "DELETE [SYSTEM | SHARED | HANDLE <Handle>] VAR <Name> "
                  "[VAR <Name>]..." + *gLineSeparatorPtr + *gLineSeparatorPtr;
        result += "LIST [SYSTEM | SHARED | HANDLE <Handle> | "
                  "ASHANDLE <Handle> | " + *gLineSeparatorPtr + 
                  "      REQUEST [<Request Number>] ] " + *gLineSeparatorPtr
                  + *gLineSeparatorPtr;
        result += "RESOLVE [SYSTEM | SHARED | HANDLE <Handle> | "
                  "ASHANDLE <Handle> | " + *gLineSeparatorPtr +
                  "         REQUEST [<Request Number>] ] " +
                  *gLineSeparatorPtr +
                  "        STRING <String> [STRING <String>]... "
                  + *gLineSeparatorPtr + *gLineSeparatorPtr;
        result += "HELP" + *gLineSeparatorPtr;
    }

    return STAFServiceResult(rc, result);
}