stafservicemanager.cpp

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

    }

    return kSTAFOk;
}


STAFRC_t STAFServiceManager::get(STAFString name, STAFServicePtr &theService,
                                 STAFString &errorBuffer, bool addingService)
{
    name.upperCase();

    {   // Extra block so that lock is released when the block is exited

        STAFMutexSemLock serviceLock(fServiceListSem);

        if (fOrderedServiceList.find(name) != fOrderedServiceList.end())
        {
            theService = fOrderedServiceList[name];
            return kSTAFOk;
        }
    }

    if (addingService)
    {
        STAFMutexSemLock authenticatorLock(fAuthenticatorMapSem);

        if (fAuthenticatorMap.find(name) != fAuthenticatorMap.end())
        {
            return kSTAFOk;
        }
    }
    else
    {
        // Service was not found.
        // If we are not adding a new service, call the SLSs

        STAFMutexSemLock serviceLock(fSLSListSem);

        // loop through all SLSs
        ServiceList::iterator listIter;

        for(listIter = fSLSList.begin(); listIter != fSLSList.end();
            ++listIter)
        {
            // send LOAD SERVICE request

            STAFServiceRequest requestInfo;

            requestInfo.fMachine = "local";
            requestInfo.fMachineNickname = *gMachineNicknamePtr;
            requestInfo.fHandle = gSTAFProcHandle;
            requestInfo.fHandleName = "ServiceLoader";   // XXX
            requestInfo.fRequest = "LOAD SERVICE " + name;
            requestInfo.fRequestNumber = 0;
            requestInfo.fDiagEnabled = gDiagManagerPtr->getEnabled();
            requestInfo.fTrustLevel = 5;    // XXX
            requestInfo.fAuthenticator = gNoneString;
            requestInfo.fUserIdentifier = gAnonymousString;
            requestInfo.fUser = gUnauthenticatedUser;
            requestInfo.fInterface = "local";
            requestInfo.fEndpoint = "local" + gSpecSeparator + "local";
            requestInfo.fPhysicalInterfaceID = "local";

            STAFServiceResult serviceResult =
                              (*listIter)->submitRequest(requestInfo);

            if (serviceResult.fRC != kSTAFOk)
            {
                errorBuffer =  STAFString(" service could not be loaded by ") +
                               (*listIter)->name() +
                               STAFString(" (") + (*listIter)->getLibName() +
                               STAFString("): RC: ") + serviceResult.fRC +
                               STAFString(" Result: ") + serviceResult.fResult;
            }

            {
                STAFMutexSemLock serviceLock(fServiceListSem);

                if (fOrderedServiceList.find(name) !=
                    fOrderedServiceList.end())
                {
                    theService = fOrderedServiceList[name];
                    return kSTAFOk;
                }
            }
        }
    }

    return kSTAFDoesNotExist;
}


STAFRC_t STAFServiceManager::getAuthenticator(const STAFString &name,
                                              STAFServicePtr &theService)
{
    STAFString upperName = name.toUpperCase();

    {
        STAFMutexSemLock serviceLock(fAuthenticatorMapSem);

        if (fAuthenticatorMap.find(upperName) != fAuthenticatorMap.end())
        {
            theService = fAuthenticatorMap[upperName];
            return kSTAFOk;
        }
    }

    return kSTAFDoesNotExist;
}


STAFServiceManager::OrderedServiceList STAFServiceManager::
                                       getOrderedServiceListCopy()
{
    STAFMutexSemLock serviceLock(fServiceListSem);

    return fOrderedServiceList;
}


STAFServiceManager::ServiceList STAFServiceManager::getServiceListCopy()
{
    STAFMutexSemLock serviceLock(fServiceListSem);

    return fServiceList;
}


STAFServiceManager::ServiceList STAFServiceManager::getSLSListCopy()
{
    STAFMutexSemLock serviceLock(fSLSListSem);

    return fSLSList;
}


STAFServiceManager::OrderedServiceList STAFServiceManager::
                                       getAuthenticatorMapCopy()
{
    STAFMutexSemLock serviceLock(fAuthenticatorMapSem);

    return fAuthenticatorMap;
}


STAFString STAFServiceManager::getDefaultAuthenticator()
{
    return fDefaultAuthenticator;
}


STAFRC_t STAFServiceManager::setDefaultAuthenticator(const STAFString &name)
{
    // Verify that the authenticator name specified is registered

    STAFString upperAuthName = name.toUpperCase();

    {
        STAFMutexSemLock serviceLock(fAuthenticatorMapSem);

        if (fAuthenticatorMap.find(upperAuthName) == fAuthenticatorMap.end())
        {
            return kSTAFDoesNotExist;
        }
    }

    fDefaultAuthenticator = name;

    return kSTAFOk;
}


// This method is called to verify that the name specified for a service
// to be added is a valid name.  Returns 0 to indicate the service name is
// valid if none of the following conditions are true:
// 1) Service name (upper-case) = "NONE"
// 2) Service name (upper-case) begins with "STAF".  This is only valid
//    for Service Loader services whose names are generated by STAF (and
//    thus, their names are not verified
// 3) Service name contains certain special characters, such that the name
//    cannot be used as a directory name to store data for the service.

STAFRC_t STAFServiceManager::verifyServiceName(const STAFString &name)
{
    STAFString upperName = name.toUpperCase();

    if ((upperName == "NONE") ||
        (upperName.length() >= 4 && upperName.subString(0,4) == "STAF") ||
        (upperName.findFirstOf("~!#$%^&*()+={[}]|;:?/<>\\") !=
         STAFString::kNPos))
    {
        return kSTAFInvalidValue;
    }

    return kSTAFOk;
}

// pass in kTraceEnabled to enable the services, or kTraceDisabled to disable
void STAFServiceManager::traceServicesChange(const STAFString &services,
    bool stateToSetTo)
{
    STAFMutexSemLock lock(sServiceTraceStatusListSem);

    for (int i = 0; i < services.numWords(); ++i)
    {
        STAFString serviceName = services.subWord(i, 1).upperCase();

        //XXX: if CHECK option is added, need to add a check here
        // to make sure the service isn't already enabled
        sServiceTraceStatusList[serviceName] = stateToSetTo;
    }
}

// pass in kTraceEnabled to enable the services, or kTraceDisabled to disable
void STAFServiceManager::traceServicesChangeAll(bool stateToSetTo)
{
    STAFMutexSemLock lock(sServiceTraceStatusListSem);

    ServiceTraceStatusList::iterator serviceTraceStatusListIter;

    for(serviceTraceStatusListIter = sServiceTraceStatusList.begin();
        serviceTraceStatusListIter != sServiceTraceStatusList.end();
        serviceTraceStatusListIter++)
    {
        serviceTraceStatusListIter->second = stateToSetTo;
    }
}

void STAFServiceManager::traceSetServices(const STAFString &services)
{
    traceServicesChangeAll(kTraceDisabled);
    traceServicesChange(services, kTraceEnabled);
}

void STAFServiceManager::purgeUnregisteredServices()
{
    ServiceTraceStatusList::iterator serviceTraceStatusListIter;

    STAFMutexSemLock lock(sServiceTraceStatusListSem);

    STAFString listToDelete = "";
    for (serviceTraceStatusListIter = sServiceTraceStatusList.begin();
        serviceTraceStatusListIter != sServiceTraceStatusList.end();
        serviceTraceStatusListIter++)
    {
        if (fOrderedServiceList.find(serviceTraceStatusListIter->first)
                == fOrderedServiceList.end())
        {
            listToDelete += serviceTraceStatusListIter->first + " ";
        }

    }
    for(int i = 0; i < listToDelete.numWords(); i++)
    {
        sServiceTraceStatusList.erase(listToDelete.subWord(i, 1));
    }
}

unsigned int STAFServiceManager::doTraceService(const STAFString &service)
{
    STAFMutexSemLock lock(sServiceTraceStatusListSem);

    if (sServiceTraceStatusList.size() == 0) return 1;

    if (sServiceTraceStatusList.find(service.toUpperCase()) !=
        sServiceTraceStatusList.end())
    {
        // Service found in the trace status list - Check if enabled

        if (sServiceTraceStatusList[service.toUpperCase()])
            return 1;
        else
            return 0;
    }
    
    // Service not found in the trace status list

    return 0;
}

STAFServiceManager::ServiceStringList STAFServiceManager::getTraceServices()
{
    ServiceStringList allTraceServices;
    ServiceTraceStatusList::iterator serviceTraceStatusListIter;

    STAFMutexSemLock lock(sServiceTraceStatusListSem);

    for (serviceTraceStatusListIter = sServiceTraceStatusList.begin();
        serviceTraceStatusListIter != sServiceTraceStatusList.end();
        serviceTraceStatusListIter++)
    {
       allTraceServices.insert(serviceTraceStatusListIter->first);
    }

    return allTraceServices;
}

STAFServiceManager::ServiceTraceStatusList STAFServiceManager::getServiceTraceStatusList()
{
    return sServiceTraceStatusList;
}

void STAFServiceManager::setDefaultTraceState(bool stateToSetTo)
{
    kDefaultTraceState = stateToSetTo;
}
bool STAFServiceManager::getDefaultTraceState()
{
    return kDefaultTraceState;
}