stafsimpleservices.cpp

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

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

#include "STAF.h"
#include "STAFString.h"
#include "STAFUtil.h"
#include "STAFProc.h"
#include "STAFProcUtil.h"
#include "STAFSimpleServices.h"
#include "STAFThreadManager.h"

STAFString STAFPingService::sPing("ping");
STAFString STAFPingService::sPong("PONG");

STAFServiceResult STAFPingService::acceptRequest(
    const STAFServiceRequest &requestInfo)
{
    if (requestInfo.fRequest.isEqualTo(sPing, kSTAFStringCaseInsensitive))
    {
        // Verify that the requesting machine/user has at least trust level 1

        IVALIDATE_TRUST(1, "PING");
        
        return STAFServiceResult(kSTAFOk, sPong);
    }
    else if (requestInfo.fRequest.subWord(0, 2).lowerCase() == "ping machine")
    {
        // PING MACHINE <Machine>

        IVALIDATE_TRUST(1, "PING");

        STAFString unresMachine = requestInfo.fRequest.subWord(2);

        if (unresMachine.length() == 0)
        {
            return STAFServiceResult(kSTAFInvalidRequestString,
                                     "Option, MACHINE, requires a value");
        }
        
        // Resolve any variables in the MACHINE option value

        DEFINE_VAR_POOL_LIST(varPoolList, varPoolListSize, requestInfo);
        STAFString errorBuffer;
        STAFString machine;
        STAFRC_t rc = RESOLVE_STRING(unresMachine, machine);
        if (rc) return STAFServiceResult(rc, errorBuffer);

        // Submit a PING request to the specified machine

        STAFResultPtr result = gSTAFProcHandlePtr->submit(
            machine, "PING", "PING");

        return STAFServiceResult(result->rc, result->result);
    }
    else if (requestInfo.fRequest.subWord(0, 1).lowerCase() == "help")
    {
        // Verify that the requesting machine/user has at least trust level 1

        IVALIDATE_TRUST(1, "HELP");

        STAFString result("PING service help" + *gLineSeparatorPtr +
                          *gLineSeparatorPtr);

        result += "PING [MACHINE <Machine>]" + *gLineSeparatorPtr +
                  "HELP" + *gLineSeparatorPtr;

        return STAFServiceResult(kSTAFOk, result);
    }
    else
        return STAFServiceResult(kSTAFInvalidRequestString);
}

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

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


STAFServiceResult STAFEchoService::acceptRequest(
    const STAFServiceRequest &requestInfo)
{
    if (requestInfo.fRequest.subWord(0, 1).lowerCase() == "echo")
    {
        // Verify that the requesting machine/user has at least trust level 2
 
        IVALIDATE_TRUST(2, "ECHO");

        return STAFServiceResult(kSTAFOk, requestInfo.fRequest.subWord(1));
    }
    else if (requestInfo.fRequest.subWord(0, 1).lowerCase() == "help")
    {
        // Verify that the requesting machine/user has at least trust level 1

        IVALIDATE_TRUST(1, "HELP");

        STAFString result("ECHO service help" + *gLineSeparatorPtr +
                          *gLineSeparatorPtr);

        result += "ECHO <Message>" + *gLineSeparatorPtr +
                  "HELP" + *gLineSeparatorPtr;

        return STAFServiceResult(kSTAFOk, result);
    }
    else
    {
        return STAFServiceResult(kSTAFInvalidRequestString);
    }
}

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

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


STAFServiceResult STAFDelayService::acceptRequest(
    const STAFServiceRequest &requestInfo)
{
    if (requestInfo.fRequest.subWord(0, 1).lowerCase() == "delay")
    {
        // Verify that the requesting machine/user has at least trust level 2

        IVALIDATE_TRUST(2, "DELAY");

        STAFString delayString = requestInfo.fRequest.subWord(1);

        if (!delayString.isDigits())
            return STAFServiceResult(kSTAFInvalidValue, delayString);

        int delay = delayString.asUInt();

        gThreadManagerPtr->sleepCurrentThread(delay);

        return STAFServiceResult(kSTAFOk);
    }
    else if (requestInfo.fRequest.subWord(0, 1).lowerCase() == "help")
    {
        // Verify that the requesting machine/user has at least trust level 1

        IVALIDATE_TRUST(1, "HELP");

        STAFString result("DELAY service help" + *gLineSeparatorPtr +
                          *gLineSeparatorPtr);

        result += "DELAY <Milliseconds>" + *gLineSeparatorPtr +
                  "HELP" + *gLineSeparatorPtr;

        return STAFServiceResult(kSTAFOk, result);
    }
    else
    {
        return STAFServiceResult(kSTAFInvalidRequestString);
    }
}

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

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