stafsemservice.cpp

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

        fMutexSemListSem.release();
        return kSTAFSemaphoreDoesNotExist;
    }

    // Ok, the semaphore exists.  Get it and lock it, then release the
    // lock on the semaphore list.

    MutexSemPtr sem = fMutexSemList[uppercaseSemName];
    STAFMutexSemLock semLock(*sem->lockPtr);

    fMutexSemListSem.release();

    // Verify we are allowed to release the semaphore

    if (((requestInfo.fSTAFInstanceUUID != sem->owner.stafInstanceUUID) ||
        (requestInfo.fHandle != sem->owner.handle)) &&
        (parsedResult->optionTimes("FORCE") == 0))
    {
        return kSTAFNotSemaphoreOwner;
    }

    gHandleManagerPtr->deleteNotification(sem->owner.handle, 
                                          sem->owner.machine,
                                          sem->owner.stafInstanceUUID,
                                          name());
        
    if (sem->requestList.size() != 0)
    {
        // There is a pending request.  Remove it from the list and
        // notify the waiter.

        sem->acquireTimeDate = STAFTimestamp::now();

        sem->owner = sem->requestList.front();
        sem->requestList.pop_front();

        sem->owner.avail->post();
    }
    else
    {
        sem->isOwned = 0;
    }

    return STAFServiceResult(kSTAFOk, result);
}

STAFServiceResult STAFSemService::handlePostPulse(
    const STAFServiceRequest &requestInfo)
{
    // Parse the request

    STAFCommandParseResultPtr parsedResult =
        fPostPulseParser.parse(requestInfo.fRequest);
 
    if (parsedResult->rc != kSTAFOk)
    {
        return STAFServiceResult(kSTAFInvalidRequestString,
                                 parsedResult->errorBuffer, 0);
    }                             

    // Verify that the requesting machine/user has at least trust level 3
    
    if (parsedResult->optionTimes("POST") != 0)
    {
        IVALIDATE_TRUST(3, "POST");
    }
    else
    {
        IVALIDATE_TRUST(3, "PULSE");
    }

    DEFINE_VAR_POOL_LIST(varPoolList, varPoolListSize, requestInfo);
    STAFString errorBuffer;
    STAFString result;
    STAFString semName;
    STAFRC_t rc = RESOLVE_STRING_OPTION("EVENT", semName);

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

    STAFString uppercaseSemName = semName.toUpperCase();

    fEventSemListSem.request();

    if (fEventSemList.find(uppercaseSemName) == fEventSemList.end())
    {
        // Semaphore does not exist, so create it in a posted state
        // if on POST, or in a reset state if on PULSE

        EventSemPtr sem = EventSemPtr(new EventSem(semName), 
                                      EventSemPtr::INIT);

        sem->lastPost = EventUnit(requestInfo.fMachine,
                                  requestInfo.fHandleName,
                                  requestInfo.fHandle,
                                  requestInfo.fUser,
                                  requestInfo.fEndpoint);

        if (parsedResult->optionTimes("POST") != 0)
        {
            sem->eventSem->post();
        }
        else
        {
            sem->eventSem->reset();
            sem->lastReset = sem->lastPost;
        }

        fEventSemList[uppercaseSemName] = sem;

        fEventSemListSem.release();
    }
    else
    {
        // The semaphore does exist, so lock the sem, unlock the main
        // list, clear the waiter list, and post/pulse it.

        EventSemPtr sem = fEventSemList[uppercaseSemName];

        sem->lockPtr->request();
        fEventSemListSem.release();

        sem->waiterList.clear();
        sem->lastPost = EventUnit(requestInfo.fMachine,
                                  requestInfo.fHandleName,
                                  requestInfo.fHandle,
                                  requestInfo.fUser,
                                  requestInfo.fEndpoint);
        sem->eventSem->post();

        if (parsedResult->optionTimes("PULSE") != 0)
        {
            sem->eventSem->reset();
            sem->lastReset = sem->lastPost;
        }

        sem->lockPtr->release();
    }

    return STAFServiceResult(kSTAFOk, result);
}

STAFServiceResult STAFSemService::handleReset(
    const STAFServiceRequest &requestInfo)
{
    // Verify that the requesting machine/user has at least trust level 3

    IVALIDATE_TRUST(3, "RESET");

    // Parse the request

    STAFCommandParseResultPtr parsedResult =
        fResetParser.parse(requestInfo.fRequest);
 
    if (parsedResult->rc != kSTAFOk)
    {
        return STAFServiceResult(kSTAFInvalidRequestString,
                                 parsedResult->errorBuffer, 0);
    }                             

    DEFINE_VAR_POOL_LIST(varPoolList, varPoolListSize, requestInfo);
    STAFString errorBuffer;
    STAFString result;
    STAFString semName;
    STAFRC_t rc = RESOLVE_STRING_OPTION("EVENT", semName);

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

    STAFString uppercaseSemName = semName.toUpperCase();

    fEventSemListSem.request();

    if (fEventSemList.find(uppercaseSemName) == fEventSemList.end())
    {
        // Semaphore does not exist, so create it in a reset state

        EventSemPtr sem = EventSemPtr(new EventSem(semName), 
                                      EventSemPtr::INIT);

        sem->lastReset = EventUnit(requestInfo.fMachine,
                                   requestInfo.fHandleName,
                                   requestInfo.fHandle,
                                   requestInfo.fUser,
                                   requestInfo.fEndpoint);
        sem->eventSem->reset();

        fEventSemList[uppercaseSemName] = sem;

        fEventSemListSem.release();
    }
    else
    {
        // The semaphore does exist, so lock the sem, unlock the main
        // list, and reset it.

        EventSemPtr sem = fEventSemList[uppercaseSemName];

        sem->lockPtr->request();
        fEventSemListSem.release();

        sem->lastReset = EventUnit(requestInfo.fMachine,
                                   requestInfo.fHandleName,
                                   requestInfo.fHandle,
                                   requestInfo.fUser,
                                   requestInfo.fEndpoint);
        sem->eventSem->reset();

        sem->lockPtr->release();
    }

    return STAFServiceResult(kSTAFOk, result);
}

STAFServiceResult STAFSemService::handleWait(
    const STAFServiceRequest &requestInfo)
{
    // Verify that the requesting machine/user has at least trust level 3

    IVALIDATE_TRUST(3, "WAIT");
    
    // Parse the request
    
    STAFCommandParseResultPtr parsedResult =
        fWaitParser.parse(requestInfo.fRequest);
 
    if (parsedResult->rc != kSTAFOk)
    {
        return STAFServiceResult(kSTAFInvalidRequestString,
                                 parsedResult->errorBuffer, 0);
    }                             

    DEFINE_VAR_POOL_LIST(varPoolList, varPoolListSize, requestInfo);
    STAFString errorBuffer;
    STAFString result;
    STAFString semName;
    STAFRC_t rc = RESOLVE_STRING_OPTION("EVENT", semName);

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

    STAFString uppercaseSemName = semName.toUpperCase();

    unsigned int timeout = STAF_EVENT_SEM_INDEFINITE_WAIT;
    
    rc = RESOLVE_DEFAULT_UINT_OPTION("TIMEOUT", timeout,
                                     STAF_EVENT_SEM_INDEFINITE_WAIT);

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

    EventUnit us = EventUnit(requestInfo.fMachine,
                             requestInfo.fHandleName,
                             requestInfo.fHandle,
                             requestInfo.fUser,
                             requestInfo.fEndpoint);
    EventSemPtr sem;

    fEventSemListSem.request();

    if (fEventSemList.find(uppercaseSemName) == fEventSemList.end())
    {
        // Semaphore does not exist, so create it in a reset state

        sem = EventSemPtr(new EventSem(semName), EventSemPtr::INIT);

        sem->lastReset = us;
        sem->eventSem->reset();

        fEventSemList[uppercaseSemName] = sem;
    }
    else
    {
        // The semaphore does exist, so get it.

        sem = fEventSemList[uppercaseSemName];
    }

    // Lock the semaphore, and unlock the main list.

    sem->lockPtr->request();
    fEventSemListSem.release();

    // First check to make sure that the semaphore is not already posted.
    // If it is posted, simply unlock the semaphore and return.

    if (sem->eventSem->query() == kSTAFEventSemPosted)
    {
        sem->lockPtr->release();
        return kSTAFOk;
    }

    // Ok, the semaphore is reset, so add us to the waiting list, and
    // unlock the semaphore.

    sem->waiterList.push_front(us);
    sem->lockPtr->release();

    // Now wait on it

    unsigned int waitRC = sem->eventSem->wait(timeout);

    // Re-acquire our lock on the semaphore

    sem->lockPtr->request();

    if (waitRC == 0)
    {
        // The sem was posted while we were trying to get a lock.
        // Yeah!!  We were removed from the waiting list by the
        // posting thread.

        sem->lockPtr->release();
    }
    else
    {
        // We timed out waiting for the semaphore, so remove
        // us from the waiting list

        int foundUs = 0;
        EventWaiterList::iterator iter;

        for(iter = sem->waiterList.begin(); !foundUs && 
            iter != sem->waiterList.end(); iter++)
        {
            if ((iter->machine == requestInfo.fMachine) &&
                (iter->handleName == requestInfo.fHandleName) &&
                (iter->handle == requestInfo.fHandle))
            {
                foundUs = 1;
                sem->waiterList.erase(iter);
                break;
            }
        }

        // Now unlock the semaphore and return a timeout error

        sem->lockPtr->release();

        return kSTAFTimeout;
    }

    return STAFServiceResult(kSTAFOk, result);
}

STAFServiceResult STAFSemService::handleDelete(
    const STAFServiceRequest &requestInfo)
{
    // Verify that the requesting machine/user has at least trust level 4

    IVALIDATE_TRUST(4, "DELETE");

    // Parse the request

    STAFCommandParseResultPtr parsedResult =
        fDeleteParser.parse(requestInfo.fRequest);
 
    if (parsedResult->rc != kSTAFOk)
    {
        return STAFServiceResult(kSTAFInvalidRequestString,
                                 parsedResult->errorBuffer, 0);
    }

    DEFINE_VAR_POOL_LIST(varPoolList, varPoolListSize, requestInfo);
    STAFString errorBuffer;
    STAFString result;
    STAFString semName;

    if (parsedResult->optionTimes("MUTEX") != 0)
    {
        STAFRC_t rc = RESOLVE_STRING_OPTION("MUTEX", semName);

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

        STAFString uppercaseSemName = semName.toUpperCase();

        STAFMutexSemLock lock(fMutexSemListSem);

        if (fMutexSemList.find(uppercaseSemName) == fMutexSemList.end())
            return kSTAFSemaphoreDoesNotExist;

        // Ok, the semaphore exists.  Get it and lock it.

        MutexSemPtr sem = fMutexSemList[uppercaseSemName];
        STAFMutexSemLock semLock(*sem->lockPtr);

        if (!sem->isOwned)
            fMutexSemList.erase(uppercaseSemName);
        else
            return kSTAFSemaphoreHasPendingRequests;
    }
    else
    {
        STAFRC_t rc = RESOLVE_STRING_OPTION("EVENT", semName);

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

        STAFString uppercaseSemName = semName.toUpperCase();

        STAFMutexSemLock lock(fEventSemListSem);

        if (fEventSemList.find(uppercaseSemName) == fEventSemList.end())
            return kSTAFSemaphoreDoesNotExist;

        // Ok, the semaphore exists.  Get it and lock it.

        EventSemPtr sem = fEventSemList[uppercaseSemName];
        STAFMutexSemLock semLock(*sem->lockPtr);

        if (sem->waiterList.empty())
            fEventSemList.erase(uppercaseSemName);
        else
            return kSTAFSemaphoreHasPendingRequests;
    }
    
    return STAFServiceResult(kSTAFOk, result);
}

STAFServiceResult STAFSemService::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,