stafsemservice.cpp

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

                                 parsedResult->errorBuffer, 0);
    }

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

    STAFObjectPtr mc = STAFObject::createMarshallingContext();

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

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

        STAFString uppercaseSemName = semName.toUpperCase();
        
        fMutexSemListSem.request();

        if (fMutexSemList.find(uppercaseSemName) == fMutexSemList.end())
        {
            fMutexSemListSem.release();
            return kSTAFSemaphoreDoesNotExist;
        }

        // Create a marshalled map containing information about the semaphore

        mc->setMapClassDefinition(fQueryMutexClass->reference());
        mc->setMapClassDefinition(fMutexOwnerClass->reference());
        mc->setMapClassDefinition(fPendingRequestClass->reference());
        STAFObjectPtr mutexMap = fQueryMutexClass->createInstance();

        // 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();

        STAFObjectPtr pendingRequests = STAFObject::createList();

        if (sem->isOwned)
        {
            mutexMap->put("state", "Owned");

            STAFObjectPtr ownerMap = fMutexOwnerClass->createInstance();
            ownerMap->put("machine", sem->owner.machine);
            ownerMap->put("handleName", sem->owner.handleName);
            ownerMap->put("handle", STAFString(sem->owner.handle));
            ownerMap->put("user", sem->owner.user);
            ownerMap->put("endpoint", sem->owner.endpoint);
            ownerMap->put("requestTimestamp",
                          sem->owner.timeDate.asString());
            ownerMap->put("acquireTimestamp",
                          sem->acquireTimeDate.asString());

            mutexMap->put("owner", ownerMap);

            if (!sem->requestList.empty())
            {
                MutexRequestList::iterator iter;
                int i = 1;

                for(iter = sem->requestList.begin();
                    iter != sem->requestList.end();
                    ++i, ++iter)
                {
                    MutexRequest request = *iter;

                    STAFObjectPtr requestMap =
                        fPendingRequestClass->createInstance();

                    requestMap->put("machine", request.machine);
                    requestMap->put("handleName", request.handleName);
                    requestMap->put("handle", STAFString(request.handle));
                    requestMap->put("user", request.user);
                    requestMap->put("endpoint", request.endpoint);
                    requestMap->put("requestTimestamp",
                                    request.timeDate.asString());

                    pendingRequests->append(requestMap);
                }
            }

        }
        else
        {
            mutexMap->put("state", "Unowned");
        }

        mutexMap->put("requestList", pendingRequests);

        mc->setRootObject(mutexMap);
    }
    else
    {
        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())
        {
            fEventSemListSem.release();
            return kSTAFSemaphoreDoesNotExist;
        }

        // Create a marshalled map containing information about the semaphore

        mc->setMapClassDefinition(fQueryEventClass->reference());
        mc->setMapClassDefinition(fEventRequesterClass->reference());
        STAFObjectPtr eventMap = fQueryEventClass->createInstance();

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

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

        fEventSemListSem.release();

        if (sem->eventSem->query() == kSTAFEventSemPosted)
            eventMap->put("state", STAFString("Posted"));
        else
            eventMap->put("state", STAFString("Reset"));

        STAFObjectPtr lastPostedMap = fEventRequesterClass->createInstance();

        lastPostedMap->put("machine", sem->lastPost.machine);
        lastPostedMap->put("handleName", sem->lastPost.handleName);
        lastPostedMap->put("handle", STAFString(sem->lastPost.handle));
        lastPostedMap->put("user", sem->lastPost.user);
        lastPostedMap->put("endpoint", sem->lastPost.endpoint);
        lastPostedMap->put("timestamp", sem->lastPost.timeDate.asString());

        eventMap->put("lastPosted", lastPostedMap);

        STAFObjectPtr lastResetMap = fEventRequesterClass->createInstance();

        lastResetMap->put("machine", sem->lastReset.machine);
        lastResetMap->put("handleName", sem->lastReset.handleName);
        lastResetMap->put("handle", STAFString(sem->lastReset.handle));
        lastResetMap->put("user", sem->lastReset.user);
        lastResetMap->put("endpoint", sem->lastReset.endpoint);
        lastResetMap->put("timestamp", sem->lastReset.timeDate.asString());

        eventMap->put("lastReset", lastResetMap);
        
        STAFObjectPtr outputList = STAFObject::createList();

        if (sem->eventSem->query() == kSTAFEventSemReset)
        {
            if (sem->waiterList.size() != 0)
            {
                EventWaiterList::iterator iter;
                int i = 1;

                for(iter = sem->waiterList.begin();
                    iter != sem->waiterList.end(); ++i, ++iter)
                {
                    EventUnit eventUnit = *iter;

                    STAFObjectPtr waiterMap =
                        fEventRequesterClass->createInstance();
                    waiterMap->put("machine", eventUnit.machine);
                    waiterMap->put("handleName", eventUnit.handleName);
                    waiterMap->put("handle", STAFString(eventUnit.handle));
                    waiterMap->put("user", eventUnit.user);
                    waiterMap->put("endpoint", eventUnit.endpoint);
                    waiterMap->put("timestamp", eventUnit.timeDate.asString());

                    outputList->append(waiterMap);
                }
            }

        }

        eventMap->put("waiterList", outputList);

        mc->setRootObject(eventMap);
    }

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

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

    IVALIDATE_TRUST(2, "LIST");

    // Parse the request

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

    STAFObjectPtr mc = STAFObject::createMarshallingContext();

    if (parsedResult->optionTimes("MUTEX") != 0)
    {
        // Create a marshalled list of maps containing mutex semaphore info

        mc->setMapClassDefinition(fMutexInfoClass->reference());
        STAFObjectPtr outputList = STAFObject::createList();
        
        STAFMutexSemLock lock(fMutexSemListSem);
        MutexSemList::iterator iter;

        for(iter = fMutexSemList.begin(); iter != fMutexSemList.end(); iter++)
        {
            MutexSemPtr sem = iter->second;
            STAFMutexSemLock semLock(*sem->lockPtr);

            STAFObjectPtr mutexInfoMap = fMutexInfoClass->createInstance();

            mutexInfoMap->put("name", STAFString(sem->name));

            if (sem->isOwned)
            {
                mutexInfoMap->put("state", STAFString("Owned"));
            }
            else
            {
                mutexInfoMap->put("state", STAFString("Unowned"));
            }

            mutexInfoMap->put("pendingRequests",
                              STAFString(sem->requestList.size()));

            outputList->append(mutexInfoMap);
        }

        mc->setRootObject(outputList);
    }
    else
    {
       // Create a marshalled list of maps containing event semaphore info

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

        STAFMutexSemLock lock(fEventSemListSem);
        EventSemList::iterator iter;
        
        for(iter = fEventSemList.begin(); iter != fEventSemList.end(); iter++)
        {
            EventSemPtr sem = iter->second;
            STAFMutexSemLock semLock(*sem->lockPtr);

            STAFObjectPtr eventInfoMap = fEventInfoClass->createInstance();

            eventInfoMap->put("name", STAFString(sem->name));

            if (sem->eventSem->query() == kSTAFEventSemReset)
            {
                eventInfoMap->put("state", STAFString("Reset"));
            }
            else
            {
                eventInfoMap->put("state", STAFString("Posted"));
            }

            eventInfoMap->put("waiters", STAFString(sem->waiterList.size()));

            outputList->append(eventInfoMap);
        }

        mc->setRootObject(outputList);
    }

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


STAFServiceResult STAFSemService::handleSTAFCallback(
    const STAFServiceRequest &requestInfo)
{
    STAFString result = " ";

    // Don't check the TRUST level, but make sure the requesting handle
    // is the STAFProc handle

    if (requestInfo.fHandle != 1)
    {
        // XXX Return a non-zero RC?
        return STAFServiceResult(kSTAFOk, result);
    }
    
    STAFCommandParseResultPtr parsedResult =
        fSTAFCallbackParser.parse(requestInfo.fRequest);
 
    if (parsedResult->rc != kSTAFOk)
    {
        return STAFServiceResult(kSTAFInvalidRequestString,
                                 parsedResult->errorBuffer, 0);
    }
    
    STAFString handle = parsedResult->optionValue("HANDLE");
    STAFString machine = parsedResult->optionValue("MACHINE");
    STAFString uuid = parsedResult->optionValue("UUID");
    
    STAFMutexSemLock lock(fMutexSemListSem);
    MutexSemList::iterator iter;

    // For each mutex semaphore, perform garbage collection as follows:
    // 1) Remove any pending requests that were requested by this handle
    //    that no longer exists, and
    // 2) Release the mutex semaphore if owned by this handle that no
    //    longer exists and wake up any pending requests

    for(iter = fMutexSemList.begin(); iter != fMutexSemList.end(); iter++)
    {
        MutexSemPtr sem = fMutexSemList[iter->second->uppercaseName];
        STAFMutexSemLock semLock(*sem->lockPtr);

        // First, remove any pending requests for this mutex semaphore that
        // were requested by this handle that no longer exists
        
        if (sem->requestList.size() > 0)
        {
            bool removedRequest = true;

            while (removedRequest)
            {
                removedRequest = false;
                MutexRequestList::iterator reqListIter;

                for (reqListIter = sem->requestList.begin();
                     reqListIter != sem->requestList.end(); ++reqListIter)
                {
                    // Check if this handle submitted the pending request

                    if ((reqListIter->machine == machine) &&
                        (STAFString(reqListIter->handle) == handle) &&
                        (reqListIter->stafInstanceUUID == uuid))
                    {
                        // The handle for this pending request no longer
                        // exists, so remove this pending request

                        sem->requestList.erase(reqListIter);

                        // Set the flag indicating that the pending request
                        // has been garbage collected and wake up the
                        // requester

                        *reqListIter->garbageCollectedPtr = true;
                        reqListIter->avail->post();
                          
                        // Break since can't continue iterating a list
                        // that has been changed

                        removedRequest = true;
                        break;
                    }
                }
            }
        }

        // Second, release the mutex semaphore if owned by this handle that
        // no longer exists and then wake up any pending requests

        if ((STAFString(sem->owner.handle) == handle) && 
            (sem->owner.machine == machine) && 
            (sem->owner.stafInstanceUUID == uuid))
        {
            // Verify we are allowed to release the semaphore
            
            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::handleHelp(
    const STAFServiceRequest &requestInfo)
{
    // Verify that the requesting machine/user has at least trust level 1

    IVALIDATE_TRUST(1, "HELP");

    STAFString result("SEM (Semaphore) Service Help" + *gLineSeparatorPtr +
                       *gLineSeparatorPtr);

    result += "REQUEST MUTEX <Name> [TIMEOUT <Timeout>]" +
              *gLineSeparatorPtr;
    result += "RELEASE MUTEX <Name> [FORCE]" + *gLineSeparatorPtr +
              *gLineSeparatorPtr;
    result += "POST    EVENT <Name>" + *gLineSeparatorPtr;
    result += "RESET   EVENT <Name>" + *gLineSeparatorPtr;
    result += "PULSE   EVENT <Name>" + *gLineSeparatorPtr;
    result += "WAIT    EVENT <Name> [TIMEOUT <Timeout>]" + *gLineSeparatorPtr +
              *gLineSeparatorPtr;
    result += "DELETE  MUTEX <Name> | Event <Name>" + *gLineSeparatorPtr;
    result += "QUERY   MUTEX <Name | Event <Name>" + *gLineSeparatorPtr;
    result += "LIST    MUTEX | EVENT" + *gLineSeparatorPtr;
    result += "HELP" + *gLineSeparatorPtr;

    return STAFServiceResult(kSTAFOk, result);
}