stafmiscservice.cpp

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

    IVALIDATE_TRUST(2, "LIST");

    // Parse the request

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

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

    // Create a marshalling context to represent the result

    STAFObjectPtr mc = STAFObject::createMarshallingContext();

    if (parsedResult->optionTimes("INTERFACES") > 0)
    {
        // LIST INTERFACES

        // Create a marshalled list of maps containing interface information

        mc->setMapClassDefinition(fInterfaceClass->reference());
        STAFObjectPtr outputList = STAFObject::createList();
    
        STAFConnectionManager::ConnectionProviderList connProvList =
            gConnectionManagerPtr->getConnectionProviderListCopy();

        for (STAFConnectionManager::ConnectionProviderList::iterator
             iter = connProvList.begin(); iter != connProvList.end(); ++iter)
        {
            STAFObjectPtr interfaceMap = fInterfaceClass->createInstance();
            interfaceMap->put("name", (*iter)->getName());
            interfaceMap->put("library", (*iter)->getLibrary());

            // Get the options from the connection provider

            STAFObjectPtr options;
            (*iter)->getOptions(options);
            interfaceMap->put("optionMap", options->reference());

            outputList->append(interfaceMap);
        }

        mc->setRootObject(outputList);

        // Get rid of connection provider references
        connProvList = STAFConnectionManager::ConnectionProviderList();
    }
    else if (parsedResult->optionTimes("ENDPOINTCACHE") > 0)
    {
        // LIST ENDPOINTCACHE

        // Create a marshalled list of maps representing the entries in the
        // endpoint cache map.

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

        STAFConnectionManager::EndpointCacheMap cacheMap =
            gConnectionManagerPtr->getEndpointCacheMapCopy();

        for (STAFConnectionManager::EndpointCacheMap::iterator
             iter = cacheMap.begin(); iter != cacheMap.end(); ++ iter)
        {
            STAFObjectPtr outputMap = fListCacheClass->createInstance();

            outputMap->put("endpoint", (*iter).first);
            outputMap->put("interface", (*iter).second.interface);
            outputMap->put("createdTimestamp",
                           (*iter).second.createdTimestamp.asString());

            outputList->append(outputMap);
        }

        mc->setRootObject(outputList);

        // Get rid of cache map references

        cacheMap = STAFConnectionManager::EndpointCacheMap();
    }
    else
    {
        // LIST SETTINGS

        // Create a marshalled map containing settings information

        mc->setMapClassDefinition(fSettingsClass->reference());
        STAFObjectPtr settingsMap = fSettingsClass->createInstance();
        settingsMap->put("connectAttempts",
                         STAFString(gConnectionAttempts));
        settingsMap->put("connectRetryDelay",
                         STAFString(gConnectionRetryDelay));

        if (gConnectionManagerPtr->getAutoInterfaceCycling())
            settingsMap->put("interfaceCycling", "Enabled");
        else
            settingsMap->put("interfaceCycling", "Disabled");

        settingsMap->put("maxQueueSize", STAFString(gMaxQueueSize));
        settingsMap->put("initialThreads", STAFString(gNumInitialThreads));
        settingsMap->put("threadGrowthDelta",
                         STAFString(gThreadManagerPtr->getGrowthDelta()));
        settingsMap->put("dataDir", *gSTAFWriteLocationPtr);
        settingsMap->put("defaultInterface",
                         gConnectionManagerPtr->getDefaultConnectionProvider());
        settingsMap->put("defaultAuthenticator",
                         gServiceManagerPtr->getDefaultAuthenticator());

        if (gResultCompatibilityMode == kSTAFResultCompatibilityVerbose)
            settingsMap->put("resultCompatibilityMode", "Verbose");
        else
            settingsMap->put("resultCompatibilityMode", "None");

        mc->setRootObject(settingsMap);
    }

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


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

    IVALIDATE_TRUST(5, "PURGE");

    // Parse the request

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

    if (parsedResult->rc != kSTAFOk)
    {
        return STAFServiceResult(kSTAFInvalidRequestString,
                                 parsedResult->errorBuffer, 0);
    }
    
    DEFINE_VAR_POOL_LIST(varPoolList, varPoolListSize, requestInfo);
    STAFString errorBuffer;
    STAFRC_t rc = 0;

    unsigned int numPurged = 0;
    unsigned int numTotal = gConnectionManagerPtr->getEndpointCacheSize();
    
    if (parsedResult->optionTimes("CONFIRM"))
    {
        // Purge all entries from the Endpoint Cache

        rc = gConnectionManagerPtr->purgeEndpointCache();

        if (rc == kSTAFOk)
            numPurged = numTotal;
    }
    else
    {
        // Remove each specified endpoint from the Endpoint Cache

        // Create a list of the resolved endpoints to be purged

        unsigned int numEndpoints = parsedResult->optionTimes("ENDPOINT");
        std::vector<STAFString> endpointList;
        unsigned int i = 0;

        for (i = 1; i <= numEndpoints; ++i)
        {
            STAFString endpoint;
            rc = RESOLVE_INDEXED_STRING_OPTION("ENDPOINT", i, endpoint);

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

            endpointList.push_back(endpoint);
        }

        // Iterate through endpoint list and remove each endpoint from
        // the cache

        for (i = 0; i < endpointList.size(); ++i)
        {
            rc = gConnectionManagerPtr->removeFromEndpointCache(
                endpointList[i]);

            if (rc == kSTAFOk)
                numPurged++;
        }
    }

    // Create a marshalling context to represent the result

    STAFObjectPtr mc = STAFObject::createMarshallingContext();
    mc->setMapClassDefinition(fPurgeCacheClass->reference());
    STAFObjectPtr resultMap = fPurgeCacheClass->createInstance();
    resultMap->put("numPurged",   STAFString(numPurged));
    resultMap->put("numRemaining", STAFString(numTotal - numPurged));
    mc->setRootObject(resultMap);

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


STAFServiceResult STAFMiscService::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);
    }

    DEFINE_VAR_POOL_LIST(varPoolList, varPoolListSize, requestInfo);
    STAFString errorBuffer;
    STAFRC_t rc = 0;

    if (parsedResult->optionTimes("CONNECTATTEMPTS") > 0)
    {
        // SET CONNECTATTEMPTS

        STAFString connectAttempts;
        rc = RESOLVE_STRING_OPTION("CONNECTATTEMPTS", connectAttempts);

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

        if (!connectAttempts.isDigits() || (connectAttempts.asUInt() < 1))
        {
            return STAFServiceResult(
                kSTAFInvalidValue,
                "CONNECTATTEMPTS must be a positive integer");
        }
        
        // Use a mutex semaphore to get exclusive access to gConnectionAttempts
        
        STAFMutexSemLock lock(sConnectAttemptsSem);
        gConnectionAttempts = connectAttempts.asUInt();
    }

    if (parsedResult->optionTimes("CONNECTRETRYDELAY") > 0)
    {
        // SET CONNECTRETRYDELAY

        STAFString connectRetryDelay;
        rc = RESOLVE_STRING_OPTION("CONNECTRETRYDELAY", connectRetryDelay);

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

        if (!connectRetryDelay.isDigits())
        {
            return STAFServiceResult(
                kSTAFInvalidValue,
                "CONNECTRETRYDELAY must be a non-negative integer");
        }
        
        // Use a mutex semaphore to get exclusive access to
        // gConnectionRetryDelay
        
        STAFMutexSemLock lock(sConnectRetryDelaySem);
        gConnectionRetryDelay = connectRetryDelay.asUInt();
    }

    if (parsedResult->optionTimes("INTERFACECYCLING") > 0)
    {
        // SET INTERFACECYCLING

        STAFString interfaceCycling;
        rc = RESOLVE_STRING_OPTION("INTERFACECYCLING", interfaceCycling);

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

        if (interfaceCycling.toUpperCase() == "ENABLED")
        {
            gConnectionManagerPtr->enableAutoInterfaceCycling();
        }
        else if (interfaceCycling.toUpperCase() == "DISABLED")
        {
            gConnectionManagerPtr->disableAutoInterfaceCycling();
        }
        else
        {
            return STAFServiceResult(
                kSTAFInvalidValue,
                "INTERFACECYCLING must be set to Enabled or Disabled");
        }
    }

    if (parsedResult->optionTimes("MAXQUEUESIZE") > 0)
    {
        // SET MAXQUEUESIZE

        STAFString maxQueueSize;

        rc = RESOLVE_STRING_OPTION("MAXQUEUESIZE", maxQueueSize);

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

        if (!maxQueueSize.isDigits())
        {
            return STAFServiceResult(
                kSTAFInvalidValue,
                "MAXQUEUESIZE must be a non-negative integer");
        }

        // Use a mutex semaphore to get exclusive access to gMaxQueueSize
        
        STAFMutexSemLock lock(sMaxQueueSizeSem);
        gMaxQueueSize = maxQueueSize.asUInt();
    }

    if (parsedResult->optionTimes("DEFAULTINTERFACE") > 0)
    {
        // SET DEFAULTINTERFACE

        STAFString defaultInterface;

        rc = RESOLVE_STRING_OPTION("DEFAULTINTERFACE", defaultInterface);

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

        // Use a mutex semaphore to get exclusive access to the default
        // interface
        
        {
            STAFMutexSemLock lock(sDefaultInterfaceSem);
            rc = gConnectionManagerPtr->setDefaultConnectionProvider(
                defaultInterface);
        }

        if (rc)
        {
            return STAFServiceResult(
                rc, "DEFAULTINTERFACE " + defaultInterface +
                " is not registered");
        }

        // Change the global STAF/Config/DefaultInterface variable value

        (*gGlobalVariablePoolPtr)->set("STAF/Config/DefaultInterface",
                                       defaultInterface);
    }

    if (parsedResult->optionTimes("DEFAULTAUTHENTICATOR") > 0)
    {
        // SET DEFAULTAUTHENTICATOR

        STAFString defaultAuth;

        rc = RESOLVE_STRING_OPTION("DEFAULTAUTHENTICATOR", defaultAuth);

        // Use a mutex semaphore to get exclusive access to the default
        // authenticator
        
        {
            STAFMutexSemLock lock(sDefaultAuthenticatorSem);
            rc = gServiceManagerPtr->setDefaultAuthenticator(defaultAuth);
        }

        if (rc)
        {
            return STAFServiceResult(
                rc, "DEFAULTAUTHENTICATOR " + defaultAuth +
                " is not registered");
        }
        
        // Change the global STAF/Config/DefaultAuthenticator variable value

        (*gGlobalVariablePoolPtr)->set("STAF/Config/DefaultAuthenticator",
                                       defaultAuth);
    }

    if (parsedResult->optionTimes("RESULTCOMPATIBILITYMODE") > 0)
    {
        // SET RESULTCOMPATIBILITYMODE

        STAFString mode;
        rc = RESOLVE_STRING_OPTION("RESULTCOMPATIBILITYMODE", mode);

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

        if (mode.isEqualTo("NONE", kSTAFStringCaseInsensitive))
        {
            // Use a mutex semaphore to get exclusive access to
            // gResultCompatibilityMode
         
            STAFMutexSemLock lock(sResultCompatibilityModeSem);
            gResultCompatibilityMode = kSTAFResultCompatibilityNone;
        }
        else if (mode.isEqualTo("VERBOSE", kSTAFStringCaseInsensitive))
        {
            // Use a mutex semaphore to get exclusive access to
            // gResultCompatibilityMode
         
            STAFMutexSemLock lock(sResultCompatibilityModeSem);
            gResultCompatibilityMode = kSTAFResultCompatibilityVerbose;
        }
        else
        {
            return STAFServiceResult(
                kSTAFInvalidValue,
                "RESULTCOMPATIBILITYMODE must be None or Verbose");
        }
    }

    return STAFServiceResult(kSTAFOk);
}


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

    IVALIDATE_TRUST(2, "QUERY");

    // Parse the request

    STAFCommandParseResultPtr parsedResult =