stafqueueservice.cpp

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

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

#include "STAF.h"
#include "STAFProc.h"
#include "STAFProcUtil.h"
#include "STAFQueueService.h"
#include "STAFHandleQueue.h"
#include "STAFHandleManager.h"
#include "STAFVariablePool.h"
#include "STAFUtil.h"
// XXX: Remove STAFServiceManager.h if pass in default authenticator via
//      LocalRequest()
#include "STAFServiceManager.h"

// QUEUE  [HANDLE <Handle>] | [NAME <Name>] [PRIORITY <Priority>] 
//        [TYPE <Type>]... MESSAGE <Message>
// GET    [PRIORITY <Priority>]... [MACHINE <Machine>]... [NAME <Name>]...
//        [HANDLE <Handle>]... [USER <User>]... [TYPE <Type>]...
//        [CONTAINS <String>]... [ICONTAINS <String>]... [WAIT [Timeout]]
// PEEK   [PRIORITY <Priority>]... [MACHINE <Machine>]... [NAME <Name>]...
//        [HANDLE <Handle>]... [USER <User>]... [TYPE <Type>]...
//        [CONTAINS <String>]... [ICONTAINS <String>]... [WAIT [Timeout]]
// DELETE [PRIORITY <Priority>]... [MACHINE <Machine>]... [NAME <Name>]...
//        [HANDLE <Handle>]... [USER <User>]... [TYPE <Type>]...
//        [CONTAINS <String>]... [ICONTAINS <String>]... [WAIT [Timeout]]
// LIST   [HANDLE <Handle>]
//
// Returned elements are in the form
//
// Priority:YYYYMMDD-HH:MM:SS:Machine:Process:Handle:Message

static const STAFString sColon(kUTF8_COLON);

STAFQueueService::STAFQueueService() : STAFService("QUEUE")
{
    // queue options

    fQueueParser.addOption("QUEUE",    1,
        STAFCommandParser::kValueNotAllowed);
    fQueueParser.addOption("HANDLE",   1,
        STAFCommandParser::kValueRequired);
    fQueueParser.addOption("NAME",     1,
        STAFCommandParser::kValueRequired);
    fQueueParser.addOption("PRIORITY", 1,
        STAFCommandParser::kValueRequired);
    fQueueParser.addOption("MESSAGE",  1,
        STAFCommandParser::kValueRequired);
    fQueueParser.addOption("TYPE",  1,
        STAFCommandParser::kValueRequired);

    // queue option groups

    fQueueParser.addOptionGroup("HANDLE NAME", 0, 1);
    fQueueParser.addOptionGroup("MESSAGE",     1, 1);

    // get options

    fGetParser.addOption("GET",       1,
        STAFCommandParser::kValueNotAllowed);
    fGetParser.addOption("PEEK",      1,
        STAFCommandParser::kValueNotAllowed);
    fGetParser.addOption("PRIORITY",  0,
        STAFCommandParser::kValueRequired);
    fGetParser.addOption("MACHINE",   0,
        STAFCommandParser::kValueRequired);
    fGetParser.addOption("NAME",      0,
        STAFCommandParser::kValueRequired);
    fGetParser.addOption("HANDLE",    0,
        STAFCommandParser::kValueRequired);
    fGetParser.addOption("USER",      0,
        STAFCommandParser::kValueRequired);
    fGetParser.addOption("TYPE",      0,
        STAFCommandParser::kValueRequired);
    fGetParser.addOption("CONTAINS",  0,
        STAFCommandParser::kValueRequired);
    fGetParser.addOption("ICONTAINS", 0,
        STAFCommandParser::kValueRequired);
    fGetParser.addOption("WAIT",      1,
        STAFCommandParser::kValueAllowed);

    // delete options

    fDeleteParser.addOption("DELETE",    1,
        STAFCommandParser::kValueNotAllowed);
    fDeleteParser.addOption("PRIORITY",  0,
        STAFCommandParser::kValueRequired);
    fDeleteParser.addOption("MACHINE",   0,
        STAFCommandParser::kValueRequired);
    fDeleteParser.addOption("NAME",      0,
        STAFCommandParser::kValueRequired);
    fDeleteParser.addOption("HANDLE",    0,
        STAFCommandParser::kValueRequired);
    fDeleteParser.addOption("USER",      0,
        STAFCommandParser::kValueRequired);
    fDeleteParser.addOption("TYPE",      0,
        STAFCommandParser::kValueRequired);
    fDeleteParser.addOption("CONTAINS",  0,
        STAFCommandParser::kValueRequired);
    fDeleteParser.addOption("ICONTAINS", 0,
        STAFCommandParser::kValueRequired);

    // list options

    fListParser.addOption("LIST",   1,
        STAFCommandParser::kValueNotAllowed);
    fListParser.addOption("HANDLE", 1,
        STAFCommandParser::kValueRequired);

    // Construct map class for an entry in a queue

    fQueueEntryMapClass = STAFMapClassDefinition::create(
        "STAF/Service/Queue/Entry");

    fQueueEntryMapClass->addKey("priority",   "Priority");
    fQueueEntryMapClass->setKeyProperty("priority", "display-short-name", "P");
    fQueueEntryMapClass->addKey("timestamp",  "Date-Time");
    fQueueEntryMapClass->addKey("machine",    "Machine");
    fQueueEntryMapClass->addKey("handleName", "Handle Name");
    fQueueEntryMapClass->setKeyProperty(
        "handleName", "display-short-name", "Name");
    fQueueEntryMapClass->addKey("handle",     "Handle");
    fQueueEntryMapClass->setKeyProperty("handle", "display-short-name", "H#");
    fQueueEntryMapClass->addKey("user",       "User");
    fQueueEntryMapClass->addKey("type",       "Type");
    fQueueEntryMapClass->addKey("message",    "Message");
}


STAFQueueService::~STAFQueueService()
{
    /* Do Nothing */
}


STAFString STAFQueueService::info(unsigned int) const
{
    return name() + ": Internal";
}


STAFServiceResult STAFQueueService::acceptRequest(
    const STAFServiceRequest &requestInfo)
{
    STAFString action = requestInfo.fRequest.subWord(0, 1).lowerCase();

    if      (action == "queue")  return handleQueue(requestInfo);
    else if (action == "get")    return handleGetPeek(requestInfo, true);
    else if (action == "peek")   return handleGetPeek(requestInfo, false);
    else if (action == "delete") return handleDelete(requestInfo);
    else if (action == "list")   return handleList(requestInfo);
    else if (action == "help")   return handleHelp(requestInfo);
    else return STAFServiceResult(kSTAFInvalidRequestString);
}


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

    IVALIDATE_TRUST(3, "QUEUE");

    // Parse the request

    STAFCommandParseResultPtr parsedResult = fQueueParser.parse(
        requestInfo.fRequest);

    if (parsedResult->rc != kSTAFOk)
    {
        return STAFServiceResult(kSTAFInvalidRequestString,
                                 parsedResult->errorBuffer, 0);
    }

    STAFString errorBuffer;

    // HANDLE may only default if the request came from this machine

    if ((parsedResult->optionTimes("HANDLE") == 0) &&
        (parsedResult->optionTimes("NAME") == 0) &&
        !requestInfo.fIsLocalRequest)
    {
        return STAFServiceResult(kSTAFInvalidRequestString);
    }

    DEFINE_VAR_POOL_LIST(varPoolList, varPoolListSize, requestInfo);
    STAFString name;
    STAFHandle_t theHandle = requestInfo.fHandle;
    unsigned int priority = 5;
    STAFString type;

    STAFRC_t rc = RESOLVE_OPTIONAL_STRING_OPTION("NAME", name);

    if (!rc) rc = RESOLVE_OPTIONAL_UINT_OPTION("HANDLE", theHandle);
    if (!rc) rc = RESOLVE_OPTIONAL_UINT_OPTION("PRIORITY", priority);
    if (!rc) rc = RESOLVE_OPTIONAL_STRING_OPTION("TYPE", type);

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

    // Currently we won't resolve variables in MESSAGE

    STAFHandleQueuePtr handleQueue;
    STAFString machine = requestInfo.fEndpoint;

    STAFString result;

    STAFHandleQueue::Message message(priority, machine,
                                     requestInfo.fAuthenticator,
                                     requestInfo.fUserIdentifier,
                                     requestInfo.fHandleName,
                                     requestInfo.fHandle,
                                     parsedResult->optionValue("MESSAGE"),
                                     type);

    if (parsedResult->optionTimes("NAME") == 0)
    {
        rc = gHandleManagerPtr->handleQueue(theHandle, handleQueue);

        if (rc) return STAFServiceResult(rc);

        STAFMutexSemLock queueLock(handleQueue->fQueueSem);

        if (handleQueue->fQueue.size() >= gMaxQueueSize)
        {
            return STAFServiceResult(kSTAFQueueFull,
                                     STAFString(handleQueue->fQueue.size()));
        }

        handleQueue->fQueue.insert(STAFHandleQueue::HandleQueue::value_type(
            message.priority, message));
        handleQueue->fNotify->post();
    }
    else
    {
        std::vector<STAFHandle_t> handles =
                                  gHandleManagerPtr->handlesWithName(name);

        std::vector<STAFHandle_t>::iterator iter;

        unsigned int numberQueued = handles.size();

        for (iter = handles.begin(); iter != handles.end(); iter++)
        {
            if (gHandleManagerPtr->handleQueue(*iter, handleQueue))
                --numberQueued;
            else
            {
                STAFMutexSemLock queueLock(handleQueue->fQueueSem);

                if (handleQueue->fQueue.size() >= gMaxQueueSize)
                    --numberQueued;
                else
                {
                    handleQueue->fQueue.insert(
                    STAFHandleQueue::HandleQueue::value_type(
                        message.priority, message));
                    handleQueue->fNotify->post();
                }
            }
        }

        result = STAFString(numberQueued);
    }

    return STAFServiceResult(kSTAFOk, result);
}


STAFServiceResult STAFQueueService::handleGetPeek(
    const STAFServiceRequest &requestInfo, bool isGet)
{
    // Verify that this request came from the local machine
    // No check of trust is needed since these commands are only valid
    // with respect to the submitting process' queue so just set
    // required trust level to 0.

    if (isGet)
    {
        IVALIDATE_LOCAL_TRUST(0, "GET");
    }
    else
    {
        IVALIDATE_LOCAL_TRUST(0, "PEEK");
    }

    // Parse the request

    STAFCommandParseResultPtr parsedResult = fGetParser.parse(
        requestInfo.fRequest);

    if (parsedResult->rc != kSTAFOk)
    {
        return STAFServiceResult(kSTAFInvalidRequestString,
                                 parsedResult->errorBuffer, 0);
    }

    DEFINE_VAR_POOL_LIST(varPoolList, varPoolListSize, requestInfo);
    STAFString errorBuffer;
    STAFHandleQueuePtr handleQueue;
    STAFRC_t rc = gHandleManagerPtr->handleQueue(requestInfo.fHandle,
                                                 handleQueue);
    if (rc) return STAFServiceResult(rc);

    std::vector<unsigned int> priorityList;
    std::vector<unsigned int> handleList;
    std::vector<STAFString> machineList;
    std::vector<STAFString> nameList;
    std::vector<STAFString> userList;
    std::vector<STAFString> typeList;
    std::vector<STAFString> containsList;
    std::vector<STAFString> icontainsList;

    unsigned int index = 0;
    unsigned int optionCount = 0;
    unsigned int priority = 0;

    for (index = 1, optionCount = parsedResult->optionTimes("PRIORITY");
         (index <= optionCount) && !rc; ++index)
    {
        rc = RESOLVE_INDEXED_UINT_OPTION("PRIORITY", index, priority);
        if (!rc) priorityList.push_back(priority);
    }

    STAFHandle_t theHandle = 0;

    for (index = 1, optionCount = parsedResult->optionTimes("HANDLE");