stafservicemanager.cpp

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

/*****************************************************************************/
/* Software Testing Automation Framework (STAF)                              */
/* (C) Copyright IBM Corp. 2001, 2004                                        */
/*                                                                           */
/* This software is licensed under the Common Public License (CPL) V1.0.     */
/*****************************************************************************/

#include "STAF.h"
#include "STAFServiceManager.h"
#include "STAFDiagManager.h"
#include "STAFProc.h"

STAFServiceManager::ServiceStringList STAFServiceManager::sServiceStringList;
STAFMutexSem STAFServiceManager::sServiceStringListSem;
STAFServiceManager::ServiceTraceStatusList STAFServiceManager::sServiceTraceStatusList;
STAFMutexSem STAFServiceManager::sServiceTraceStatusListSem;
STAFServiceManager::OrderedServiceList STAFServiceManager::fOrderedServiceList;

bool STAFServiceManager::kTraceEnabled = true;
bool STAFServiceManager::kTraceDisabled= false;
bool STAFServiceManager::kDefaultTraceState = kTraceEnabled;

STAFRC_t STAFServiceManager::add(STAFServicePtr theService)
{
    STAFString serviceName(theService->name());

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

        STAFMutexSemLock authenticatorLock(fAuthenticatorMapSem);

        if (fAuthenticatorMap.find(serviceName) != fAuthenticatorMap.end())
        {
            return kSTAFAlreadyExists;
        }
    }

    {
        STAFMutexSemLock serviceLock(fServiceListSem);

        if (fOrderedServiceList.find(serviceName) != fOrderedServiceList.end())
        {
            return kSTAFAlreadyExists;
        }

        fOrderedServiceList[serviceName] = theService;
        fServiceList.push_back(theService);
    }

    {
        STAFMutexSemLock serviceLock(sServiceTraceStatusListSem);

        sServiceTraceStatusList[serviceName] = kDefaultTraceState;
    }

    return kSTAFOk;
}


STAFRC_t STAFServiceManager::addSLS(STAFServicePtr theService)
{
    STAFMutexSemLock serviceLock(fSLSListSem);

    fSLSList.push_back(theService);

    return kSTAFOk;
}


STAFRC_t STAFServiceManager::addAuthenticator(STAFServicePtr theService)
{
    STAFString serviceName(theService->name());

    // Verify that the authenticator name is not the name of a service

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

        STAFMutexSemLock serviceLock(fServiceListSem);

        if (fOrderedServiceList.find(serviceName) != fOrderedServiceList.end())
        {
            return kSTAFAlreadyExists;
        }
    }

    STAFMutexSemLock authenticatorLock(fAuthenticatorMapSem);

    if (fAuthenticatorMap.find(serviceName) != fAuthenticatorMap.end())
    {
        return kSTAFAlreadyExists;
    }

    fAuthenticatorMap[serviceName] = theService;

    return kSTAFOk;
}


STAFRC_t STAFServiceManager::remove(STAFString name)
{
    name.upperCase();

    STAFMutexSemLock serviceLock(fServiceListSem);

    if (fOrderedServiceList.find(name) == fOrderedServiceList.end())
        return kSTAFDoesNotExist;

    ServiceList::iterator listIter;

    for(listIter = fServiceList.begin(); listIter != fServiceList.end();
        ++listIter)
    {
        if ((*listIter)->name() == name)
        {
            // Don't allow removing STAF internal services
            if (! (*listIter)->isUnregisterable())
                return kSTAFServiceNotUnregisterable;
            else
                fOrderedServiceList.erase(name);

            fServiceList.erase(listIter);
            break;
        }
    }

    return kSTAFOk;
}


STAFRC_t STAFServiceManager::removeSLS(STAFServicePtr theService)
{
    STAFMutexSemLock serviceLock(fSLSListSem);

    // XXX: This should be done with some form of erase_if or remove_if

    ServiceList::iterator listIter;

    for(listIter = fSLSList.begin(); listIter != fSLSList.end();
        ++listIter)
    {
        if ((*listIter) == theService)
        {
            fSLSList.erase(listIter);
            break;
        }
    }

    return kSTAFOk;
}


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

    STAFMutexSemLock serviceLock(fAuthenticatorMapSem);

    if (fAuthenticatorMap.find(upperName) == fAuthenticatorMap.end())
        return kSTAFDoesNotExist;

    fAuthenticatorMap.erase(upperName);

    return kSTAFOk;
}


STAFRC_t STAFServiceManager::replace(STAFServicePtr theService,
                                     STAFString newName,
                                     STAFString &errorBuffer)
{
    STAFServicePtr service;
    STAFString name = theService->name();
    STAFString upperName = name.upperCase();

    {
        STAFMutexSemLock serviceLock(fServiceListSem);

        // Make sure that service being replaced already exists
        if (fOrderedServiceList.find(upperName) == fOrderedServiceList.end())
        {
            errorBuffer = name;
            return kSTAFDoesNotExist;
        }

        // If the existing service is being renamed, make sure no service
        //  already exists with this new name.
        if (newName != STAFString())
        {
            if (fOrderedServiceList.find(newName.toUpperCase()) !=
                fOrderedServiceList.end())
            {
                errorBuffer = newName;
                return kSTAFAlreadyExists;
            }

            STAFMutexSemLock authenticatorLock(fAuthenticatorMapSem);

            if (fAuthenticatorMap.find(newName.toUpperCase()) !=
                fAuthenticatorMap.end())
            {
                errorBuffer = newName;
                return kSTAFAlreadyExists;
            }
        }

        ServiceList::iterator listIter;

        for(listIter = fServiceList.begin(); listIter != fServiceList.end();
            ++listIter)
        {
            if ((*listIter)->name() == upperName)
            {
                // Don't allow removing STAF internal services
                if (! (*listIter)->isUnregisterable())
                {
                    errorBuffer = name;
                    return kSTAFServiceNotUnregisterable;
                }

                service = *listIter;

                fOrderedServiceList.erase(upperName);

                if (newName == STAFString())
                    fServiceList.erase(listIter);

                break;
            }
        }

        // Add the new service
        fOrderedServiceList[theService->name()] = theService;
        fServiceList.push_back(theService);

        if (newName != STAFString())
        {
            // Change the old service's name and add back to the service list
            service->setName(newName);
            fOrderedServiceList[newName.toUpperCase()] = service;
        }
    }

    if (newName == STAFString())
    {
        // Terminate the service that was replaced
        STAFServiceResult result = service->terminate();
    }

    return kSTAFOk;
}


STAFRC_t STAFServiceManager::rename(STAFString name, STAFString newName,
                                    STAFString &errorBuffer)
{
    STAFServicePtr service;
    STAFString upperName = name.toUpperCase();

    STAFMutexSemLock serviceLock(fServiceListSem);

    // Make sure that service being rename already exists
    if (fOrderedServiceList.find(upperName) == fOrderedServiceList.end())
    {
        errorBuffer = name;
        return kSTAFDoesNotExist;
    }

    // Make sure no service already exists with this new name.
    if (fOrderedServiceList.find(newName.toUpperCase()) !=
        fOrderedServiceList.end())
    {
        errorBuffer = newName;
        return kSTAFAlreadyExists;
    }

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

        STAFMutexSemLock authenticatorLock(fAuthenticatorMapSem);

        if (fAuthenticatorMap.find(newName.toUpperCase()) !=
            fAuthenticatorMap.end())
        {
            errorBuffer = newName;
            return kSTAFAlreadyExists;
        }
    }

    ServiceList::iterator listIter;

    for(listIter = fServiceList.begin(); listIter != fServiceList.end();
        ++listIter)
    {
        if ((*listIter)->name() == upperName)
        {
            // Don't allow renaming STAF internal services
            if (! (*listIter)->isUnregisterable())
            {
                errorBuffer = name;
                return kSTAFServiceNotUnregisterable;
            }

            service = *listIter;

            fOrderedServiceList.erase(name);

            // Change the old service's name & add back to the service list
            service->setName(newName);
            fOrderedServiceList.erase(upperName);
            fOrderedServiceList[newName.toUpperCase()] = service;

            break;
        }