stafregservice.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 "STAF_fstream.h"
#include <string>
#include "STAFRefPtr.h"
#include "STAFUtil.h"
#include "STAFMutexSem.h"
#include "STAFCommandParser.h"
#include "STAFServiceInterface.h"
#include "STAFTimestamp.h"

STAFRC_t handleRegister(STAFString &, STAFString &, unsigned int,
                        STAFString &, STAFString &);

STAFRC_t handleHelp(STAFString &, STAFString &);

static const bool gDEBUG = false;
static STAFString gName("STAF/Service/");
static STAFHandlePtr gHandlePtr;
static STAFMutexSem gFileSem;
static STAFCommandParser gRegisterParser;
static const char *gFileNamePtr = "STAFReg.dat";

STAFRC_t STAFServiceGetLevelBounds(unsigned int levelID,
                                   unsigned int *minimum,
                                   unsigned int *maximum)
{
    switch (levelID)
    {
        case kServiceInfo:
        case kServiceInit:
        case kServiceAcceptRequest:
        {
            *minimum = 30;
            *maximum = 30;
            break;
        }
        case kServiceTerm:
        case kServiceDestruct:
        {
            *minimum = 0;
            *maximum = 0;
            break;
        }
        default:
        {
            return kSTAFInvalidAPILevel;
        }
    }

    return kSTAFOk;
}

STAFRC_t STAFServiceConstruct(STAFServiceHandle_t *pServiceHandle,
                              void *pServiceInfo, unsigned int infoLevel,
                              STAFString_t *pErrorBuffer)
{
    STAFRC_t rc = kSTAFUnknownError;

    try
    {
        if (infoLevel != 30) return kSTAFInvalidAPILevel;

        STAFServiceInfoLevel30 *pInfo =
            reinterpret_cast<STAFServiceInfoLevel30 *>(pServiceInfo);

        gName += pInfo->name;

        rc = kSTAFOk;
    }
    catch (STAFException &e)
    { e.write();       }
    catch (...)
    { /* Do Nothing */ }

    return rc;
}


STAFRC_t STAFServiceInit(STAFServiceHandle_t serviceHandle,
                         void *pInitInfo, unsigned int initLevel,
                         STAFString_t *pErrorBuffer)
{
    STAFRC_t rc = kSTAFUnknownError;

    try
    {
        if (initLevel != 30) return kSTAFInvalidAPILevel;

        STAFServiceInitLevel30 *pInfo =
            reinterpret_cast<STAFServiceInitLevel30 *>(pInitInfo);

        rc = STAFHandle::create(gName, gHandlePtr);

        gRegisterParser.addOption("REGISTER", 1, 
            STAFCommandParser::kValueNotAllowed);
        gRegisterParser.addOption("TYPE",     1,
            STAFCommandParser::kValueRequired);
        gRegisterParser.addOption("DATA",     1,
            STAFCommandParser::kValueRequired);

        gRegisterParser.addOptionGroup("REGISTER", 1, 1);
        gRegisterParser.addOptionGroup("DATA",     1, 1);
    }
    catch (STAFException &e)
    { e.write();       }
    catch (...)
    { /* Do Nothing */ }

    return rc;
}


STAFRC_t STAFServiceAcceptRequest(STAFServiceHandle_t serviceHandle,
                                  void *pRequestInfo, unsigned int reqLevel,
                                  STAFString_t *pResultBuffer)
{
    STAFRC_t rc = kSTAFUnknownError;

    try
    {
        if (reqLevel != 30) return kSTAFInvalidAPILevel;

        STAFServiceRequestLevel30 *pInfo =
            reinterpret_cast<STAFServiceRequestLevel30 *>(pRequestInfo);

        STAFHandlePtr handlePtr;
        STAFString machine(pInfo->machine);
        STAFString handleName(pInfo->handleName);
        STAFHandle::create(pInfo->handle, handlePtr);
        unsigned int trustLevel = pInfo->trustLevel;
        STAFString request(pInfo->request);

        if (gDEBUG)
        {
            cout << "Machine      : "
                 << machine.toCurrentCodePage()->buffer() << endl;
            cout << "Handle Name : "
                 << handleName.toCurrentCodePage()->buffer() << endl;
            cout << "Handle       : "
                 << pInfo->handle << endl;
            cout << "Trust Level  : "
                 << trustLevel << endl;
            cout << "Request      : "
                 << request.toCurrentCodePage()->buffer() << endl;
        }

        STAFString action = request.subWord(0, 1).toLowerCase();
        STAFString result;

        if (gDEBUG) cout << "ACTION = " << action << endl;

        if (action == "register") 
            rc = handleRegister(machine, handleName, pInfo->handle, request,
                                result);
        else if (action == "help")
            rc = handleHelp(machine, result);

        *pResultBuffer = result.adoptImpl();
    }
    catch (STAFException &e)
    { e.write();       }
    catch (...)
    { /* Do Nothing */ }

    return rc;
}


STAFRC_t STAFServiceTerm(STAFServiceHandle_t serviceHandle,
                         void *pTermInfo, unsigned int termLevel,
                         STAFString_t *pErrorBuffer)
{
    STAFRC_t rc = kSTAFUnknownError;

    try
    {
        if (termLevel != 0) return kSTAFInvalidAPILevel;

        rc = kSTAFOk;
    }
    catch (STAFException &e)
    { e.write();       }
    catch (...)
    { /* Do Nothing */ }

    return rc;
}


STAFRC_t STAFServiceDestruct(STAFServiceHandle_t *serviceHandle,
                             void *pDestructInfo,
                             unsigned int destructLevel,
                             STAFString_t *pErrorBuffer)
{
    STAFRC_t rc = kSTAFUnknownError;

    try
    {
        if (destructLevel != 0) return kSTAFInvalidAPILevel;

        *serviceHandle = 0;

        rc = kSTAFOk;
    }
    catch (STAFException &e)
    { e.write();       }
    catch (...)
    { /* Do Nothing */ }

    return rc;
}

STAFRC_t handleRegister(STAFString &machine, STAFString &handleName,
                        unsigned int handle, STAFString &request,
                        STAFString &result)
{
    STAFRC_t rc = kSTAFOk;

    STAFCommandParseResultPtr parsedResult = gRegisterParser.parse(request);

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

    STAFString data("machine: " + machine + ";");
    data += parsedResult->optionValue("DATA");

    STAFMutexSemLock theLock(gFileSem);

    fstream theFile(gFileNamePtr, ios::out | ios::app); 

    if (!theFile)
    {
        result = "File " + STAFString(gFileNamePtr) + " not found";
        rc = kSTAFFileOpenError;
    }
    else
    {
        if (gDEBUG)
            cout << "DATA = " << data.toCurrentCodePage()->buffer() << endl;

        theFile << "#" << STAFTimestamp().asString()
                << "##########################################" << endl
                << data.toCurrentCodePage()->buffer() << endl;
    }

    return rc;
}

STAFRC_t handleHelp(STAFString &machine, STAFString &result)
{
    result += "REGISTER <Name> DATA <Data>\n\n";
    result += "HELP\n\n";

    return kSTAFOk;
}