stafserviceservice.cpp

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

        }
    }
    else if (parsedListResult->optionTimes(sAuthenticators) > 0)
    {
        // LIST AUTHENTICATORS

        STAFServiceManager::OrderedServiceList authenticatorMap =
            gServiceManagerPtr->getAuthenticatorMapCopy();

        // Create a marshalled list of maps for authenticators
        
        mc->setMapClassDefinition(fServiceInfoClass->reference());

        STAFServiceManager::OrderedServiceList::iterator iter;

        for(iter = authenticatorMap.begin();
            iter != authenticatorMap.end(); iter++)
        {
            STAFObjectPtr authServiceMap = fServiceInfoClass->createInstance();
            authServiceMap->put("name", iter->first);

            authServiceMap->put(
                "library", STAFString(iter->second->getLibName()));

            STAFString exec = STAFString(iter->second->getExecutable());
            
            if (exec != STAFString(""))
                authServiceMap->put("executable", exec);

            outputList->append(authServiceMap);
        }
    }
    else if (parsedListResult->optionTimes(sRequests) > 0)
    {
        //  LIST REQUESTS

        bool pending = true;  // PENDING is the default
        bool complete = false;
        bool details = false;

        if (parsedListResult->optionTimes(sComplete) > 0)
        {
            complete = true;

            if (parsedListResult->optionTimes(sPending) == 0)
                pending = false;
        }

        if (parsedListResult->optionTimes("LONG") > 0)
        {
            details = true;
        }

        // Create a marshalled list of maps for requests
        
        if (!details)
            mc->setMapClassDefinition(fRequestInfoClass->reference());
        else if (pending && !complete)
            mc->setMapClassDefinition(fPendingRequestClass->reference());
        else if (complete && !pending)
            mc->setMapClassDefinition(fCompleteRequestClass->reference());
        else // pending and complete
            mc->setMapClassDefinition(fRequestInfoLongClass->reference());

        STAFRequestManager::RequestMap requestMap =
                                       gRequestManagerPtr->getRequestMapCopy();
        STAFRequestManager::RequestMap::iterator theIterator;

        STAFServiceRequestPtr serviceRequest;

        for (theIterator = requestMap.begin(); theIterator != requestMap.end();
             ++theIterator)
        {
            serviceRequest = theIterator->second;
            STAFServiceRequestState_t requestState = serviceRequest->
                fProcessingState;
            
            if ((pending  && (requestState == kSTAFServiceRequestPending)) ||
                (complete && (requestState == kSTAFServiceRequestComplete)))
            {
                STAFObjectPtr requestMap;

                if (!details)
                    requestMap = fRequestInfoClass->createInstance();
                else if (pending && !complete)
                    requestMap = fPendingRequestClass->createInstance();
                else if (complete && !pending)
                    requestMap = fCompleteRequestClass->createInstance();
                else // pending && !complete
                    requestMap = fRequestInfoLongClass->createInstance();
                
                requestMap->put("requestNumber",
                                STAFString(theIterator->first));
                requestMap->put("startTimestamp",
                                serviceRequest->fStartStamp.asString());
                requestMap->put("service",
                                STAFString(serviceRequest->fTargetService));
                requestMap->put("request",
                                STAFHandle::maskPrivateData(
                                    STAFString(serviceRequest->fRequest)));

                if (details)
                {
                    if (pending && complete)
                    {
                        if (requestState == kSTAFServiceRequestPending)
                            requestMap->put("state", sPending);
                        else if (requestState == kSTAFServiceRequestComplete)
                            requestMap->put("state", sComplete);
                    }

                    requestMap->put("targetMachine",
                                    STAFString(serviceRequest->fTargetMachine));
                    requestMap->put("sourceMachine",
                                    STAFString(serviceRequest->fEndpoint));
                    requestMap->put("sourceHandleName",
                                    STAFString(serviceRequest->fHandleName));
                    requestMap->put("sourceHandle",
                                    STAFString(serviceRequest->fHandle));

                    if (complete &&
                        (requestState == kSTAFServiceRequestComplete))
                    {
                        requestMap->put(
                            "rc", STAFString(serviceRequest->fResult.fRC));
                        requestMap->put(
                            "result",
                            STAFString(serviceRequest->fResult.fResult));
                    }
                }

                outputList->append(requestMap);
            }
        }
    }
    else
    {
        // LIST SERVICES (services is the default)

        STAFServiceManager::OrderedServiceList serviceList =
            gServiceManagerPtr->getOrderedServiceListCopy();
        STAFServiceManager::OrderedServiceList::iterator iter;

        // Create a marshalled list of maps for services

        mc->setMapClassDefinition(fServiceInfoClass->reference());
        
        for (iter = serviceList.begin(); iter != serviceList.end(); iter++)
        {
            STAFObjectPtr serviceMap = fServiceInfoClass->createInstance();
            serviceMap->put("name", iter->first);
            serviceMap->put("library", STAFString(iter->second->getLibName()));

            STAFString exec = STAFString(iter->second->getExecutable());
            
            if (exec != STAFString(""))
                serviceMap->put("executable", exec);

            outputList->append(serviceMap);
        }
    }

    mc->setRootObject(outputList);

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

STAFServiceResult STAFServiceService::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 = fQueryParser->parse(
        requestInfo.fRequest);

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

    if (parsedResult->optionTimes(sRequest))
    {
        // Handle QUERY REQUEST request

        STAFRequestNumber_t reqNum;
        STAFString reqNumString = parsedResult->optionValue(sRequest);

        if (!reqNumString.isDigits())
            return STAFServiceResult(kSTAFInvalidValue);
        else
            reqNum = reqNumString.asUInt();

        if (parsedResult->optionTimes(sStatus))
        {
            STAFServiceRequestState_t statusResult = 
                kSTAFServiceRequestStateUnknown;
            STAFRC_t rc = gRequestManagerPtr->getStatus(reqNum, &statusResult);
            return STAFServiceResult(rc, statusResult);
        }
        else if (parsedResult->optionTimes(sResult))
        {
            STAFServiceResult requestResult;
            rc = gRequestManagerPtr->getResult(reqNum, &requestResult);

            if (rc == kSTAFOk) return requestResult;
            else return STAFServiceResult(rc);
        }

        // Otherwise, return all the info about the request

        STAFServiceRequestPtr serviceRequest;
        STAFRC_t rc = gRequestManagerPtr->getRequestData(
            reqNum, serviceRequest);

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

        // Create a marshalled map containing details for the specified request

        mc->setMapClassDefinition(fQueryRequestClass->reference());
        STAFObjectPtr requestMap = fQueryRequestClass->createInstance();

        requestMap->put("requestNumber", STAFString(reqNum));

        STAFServiceRequestState_t requestState = 
            serviceRequest->fProcessingState;
 
        if (requestState == kSTAFServiceRequestPending)
            requestMap->put("state", sPending);
        else if (requestState == kSTAFServiceRequestComplete)
            requestMap->put("state", sComplete);

        requestMap->put(
            "sourceMachine", STAFString(serviceRequest->fEndpoint));
        requestMap->put(
            "sourceHandleName", STAFString(serviceRequest->fHandleName));
        requestMap->put("sourceHandle", STAFString(serviceRequest->fHandle));
        requestMap->put(
            "startTimestamp", serviceRequest->fStartStamp.asString());
        requestMap->put(
            "targetMachine", STAFString(serviceRequest->fTargetMachine));
        requestMap->put(
            "service", STAFString(serviceRequest->fTargetService));
        requestMap->put(
            "request", STAFString(serviceRequest->fRequest));

        if (requestState == kSTAFServiceRequestComplete)
        {
            requestMap->put(
                "rc", STAFString(serviceRequest->fResult.fRC));
            requestMap->put(
                "result", STAFString(serviceRequest->fResult.fResult));
        }

        mc->setRootObject(requestMap);
    }
    else if (parsedResult->optionTimes("SERVICE"))
    {
        // Handle QUERY SERVICE request

        STAFString errorBuffer;
        STAFString serviceName;

        // Resolve SERVICE value
        STAFRC_t rc = RESOLVE_STRING_OPTION("SERVICE", serviceName);

        // Get information about the service

        STAFServicePtr service;

        rc = gServiceManagerPtr->get(serviceName, service, errorBuffer);
            
        if (rc != kSTAFOk)
        {
            return STAFServiceResult(kSTAFDoesNotExist, serviceName);
        }

        mc->setMapClassDefinition(fQueryServiceClass->reference());
        STAFObjectPtr outputMap = fQueryServiceClass->createInstance();
        outputMap->put("name", service->name());
        outputMap->put("library", STAFString(service->getLibName()));

        STAFString exec = STAFString(service->getExecutable());
            
        if (exec != STAFString(""))
            outputMap->put("executable", exec);

        STAFString parms = STAFString(service->getParameters());
            
        if (parms != STAFString(""))
            outputMap->put("parameters", parms);

        outputMap->put("options", service->getOptions());

        mc->setRootObject(outputMap);
    }
    else if (parsedResult->optionTimes("AUTHENTICATOR"))
    {
        // Handle QUERY AUTHENTICATOR request

        STAFString errorBuffer;
        STAFString authName;

        // Resolve AUTHENTICATOR value
        STAFRC_t rc = RESOLVE_STRING_OPTION("AUTHENTICATOR", authName);

        // Get information about the authenticator service
        
        STAFServicePtr authenticator;

        rc = gServiceManagerPtr->getAuthenticator(authName, authenticator);

        if (rc != kSTAFOk)
        {
            return STAFServiceResult(kSTAFDoesNotExist, authName);
        }

        mc->setMapClassDefinition(fQueryServiceClass->reference());
        STAFObjectPtr outputMap = fQueryServiceClass->createInstance();
        outputMap->put("name", authenticator->name());
        outputMap->put("library", STAFString(authenticator->getLibName()));

        STAFString exec = STAFString(authenticator->getExecutable());
            
        if (exec != STAFString(""))
            outputMap->put("executable", exec);

        STAFString parms = STAFString(authenticator->getParameters());
            
        if (parms != STAFString(""))
            outputMap->put("parameters", parms);

        outputMap->put("options", authenticator->getOptions());

        mc->setRootObject(outputMap);
    }
    else if (parsedResult->optionTimes("SERVICELOADER"))
    {
        // Handle QUERY SERVICELOADER request

        STAFString errorBuffer;
        STAFString serviceLoaderName;

        // Resolve AUTHENTICATOR value
        STAFRC_t rc = RESOLVE_STRING_OPTION("SERVICELOADER",
                                            serviceLoaderName);

        // Get information about the service loader

        STAFServiceManager::ServiceList serviceLoaderList =
            gServiceManagerPtr->getSLSListCopy();
        
        STAFServiceManager::ServiceList::iterator iter;
        STAFServicePtr serviceLoader;
        bool found = false;

        for (iter = serviceLoaderList.begin();
             iter != serviceLoaderList.end(); iter++)
        {
            if ((*iter)->name() == serviceLoaderName.toUpperCase())
            {
                serviceLoader = *iter;
                found = true;
            }
        }

        if (!found)
        {
            return STAFServiceResult(kSTAFDoesNotExist, serviceLoaderName);
        }

        mc->setMapClassDefinition(fQueryServiceClass->reference());
        STAFObjectPtr outputMap = fQueryServiceClass->createInstance();
        outputMap->put("name", serviceLoader->name());
        outputMap->put("library", STAFString(serviceLoader->getLibName()));

        STAFString exec = STAFString(serviceLoader->getExecutable());

        if (exec != STAFString(""))
            outputMap->put("executable", exec);

        STAFString parms = STAFString(serviceLoader->getParameters());
            
        if (parms != STAFString(""))
            outputMap->put("parameters", parms);

        outputMap->put("options", serviceLoader->getOptions());
        
        mc->setRootObject(outputMap);
    }