stafmonitorservice.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 "STAFOSTypes.h"
#include <map>
#include "STAF_fstream.h"
#include "STAF_iostream.h"
#include "STAFString.h"
#include "STAFError.h"
#include "STAFException.h"
#include "STAFRefPtr.h"
#include "STAFMutexSem.h"
#include "STAFCommandParser.h"
#include "STAFServiceInterface.h"
#include "STAFTimestamp.h"
#include "STAFUtil.h"
#include "STAFInternalUtil.h"
#include "STAFMonitorService.h"

typedef STAFRefPtr<STAFCommandParser> STAFCommandParserPtr;

typedef std::map<STAFHandle_t, STAFString> HandleMap;

struct NameData
{
    STAFString originalCaseName;  // The case specified on the first LOG request
    STAFString message;
};

typedef std::map<STAFString, NameData> NameMap;

struct MachineData
{
    STAFString realMachineName;
    HandleMap handleMap;
    NameMap nameMap;
};

typedef std::map<STAFString, MachineData> MachineMap;

struct MonitorServiceData
{
    unsigned int fDebugMode;
    STAFString fShortName;
    STAFString fName;
    STAFHandlePtr fHandlePtr;
    unsigned int fResolveMessage;
    unsigned int fMaxRecordSize;    
    unsigned int fEnableResolveMessageVar;
    STAFCommandParserPtr fLogParser;
    STAFCommandParserPtr fQueryParser;
    STAFCommandParserPtr fListParser;
    STAFCommandParserPtr fDeleteParser;
    STAFCommandParserPtr fSetParser;
    STAFMutexSemPtr fMapSem;
    MachineMap fMap;
    STAFString fLocalMachineName;

    // Map class definitions for marshalled results
    STAFMapClassDefinitionPtr fSettingsClass; 
    STAFMapClassDefinitionPtr fHandleInfoClass;
    STAFMapClassDefinitionPtr fNameInfoClass;
    STAFMapClassDefinitionPtr fMonitorInfoClass;
};

typedef STAFRefPtr<MonitorServiceData> MonitorServiceDataPtr;

static STAFString lineSep;
static const STAFString monitorVersion("3.2.1");
static const STAFString sMachine("MACHINE");
static const STAFString sHandle("HANDLE");
static const STAFString sName("NAME");
static const STAFString sNames("NAMES");
static const STAFString sResolveMessage("RESOLVEMESSAGE");
static const STAFString sNoResolveMessage("NORESOLVEMESSAGE");
static const STAFString sMaxRecordSize("MAXRECORDSIZE");
static const STAFString sEnableResolveMessageVar("ENABLERESOLVEMESSAGEVAR");
static const STAFString sDisableResolveMessageVar("DISABLERESOLVEMESSAGEVAR");
static const STAFString sLeftCurlyBrace(kUTF8_LCURLY);
static const STAFString sSlash(kUTF8_SLASH);
static const STAFString sSpace(kUTF8_SPACE);
static const STAFString sColon(kUTF8_COLON);
static const STAFString sEqual(kUTF8_EQUAL);
static const STAFString sHandleList("Handle");
static const STAFString sSize("Size");
static const STAFString sUsing("Using ");
static const STAFString sToday("today");
static const STAFString sBefore("before");
static const STAFString sMessage("message");
static const STAFString sLocal("local");
static const STAFString sSettings("settings");
static const STAFString sMachines("machines");
static const STAFString sVar("var");
static const STAFString sHelp("help");
static const STAFString sResStrResolve("RESOLVE REQUEST ");
static const STAFString sString(" STRING ");
static STAFString sLeftCurly(kUTF8_LCURLY);

static STAFResultPtr handleLog(STAFServiceRequestLevel30 *, MonitorServiceData *);
static STAFResultPtr handleQuery(STAFServiceRequestLevel30 *,
                                 MonitorServiceData *);
static STAFResultPtr handleList(STAFServiceRequestLevel30 *,
                                MonitorServiceData *);
static STAFResultPtr handleDelete(STAFServiceRequestLevel30 *,
                                  MonitorServiceData *);
static STAFResultPtr handleSet(STAFServiceRequestLevel30 *,
                               MonitorServiceData *);
static STAFResultPtr handleHelp(STAFServiceRequestLevel30 *,
                                MonitorServiceData *);
static STAFResultPtr handleVersion(STAFServiceRequestLevel30 *,
                                   MonitorServiceData *);
static STAFResultPtr resolveStr(STAFServiceRequestLevel30 *pInfo, 
                                MonitorServiceData *pData,
                                const STAFString &theString);
static STAFResultPtr resolveOp(STAFServiceRequestLevel30 *pInfo, 
                               MonitorServiceData *pData,
                               STAFCommandParseResultPtr &parsedResult,
                               const STAFString &fOption,
                               unsigned int optionIndex = 1);
static STAFResultPtr resolveOpLocal(MonitorServiceData *pData,
                                    STAFCommandParseResultPtr &parsedResult,
                                    const STAFString &fOption,
                                    unsigned int optionIndex = 1);
static void registerHelpData(MonitorServiceData *pData,
                             unsigned int errorNumber,
                             const STAFString &shortInfo,
                             const STAFString &longInfo);
static void unregisterHelpData(MonitorServiceData *pData,
                               unsigned int errorNumber);

STAFRC_t STAFServiceGetLevelBounds(unsigned int levelID,
                                   unsigned int *minimum,
                                   unsigned int *maximum)
{
    switch (levelID)
    {
        case kServiceInfo:
        {
            *minimum = 30;
            *maximum = 30;
            break;
        }
        case kServiceInit:
        {
            *minimum = 30;
            *maximum = 30;
            break;
        }
        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);

        MonitorServiceData data;
        data.fDebugMode = 0;
        data.fMaxRecordSize = 1024;
        data.fResolveMessage = 0;        
        data.fEnableResolveMessageVar = 0;
        data.fShortName = pInfo->name;
        data.fName = "STAF/Service/";
        data.fName += pInfo->name;
        
        for (unsigned int i = 0; i < pInfo->numOptions; ++i)
        {            
            if (STAFString(pInfo->pOptionName[i]).upperCase() == "DEBUG")
            {
                data.fDebugMode = 1;
            }           
            else
            {
                STAFString optionError(pInfo->pOptionName[i]);
                *pErrorBuffer = optionError.adoptImpl();
                return kSTAFServiceConfigurationError;
            }
        }        

        // Set service handle

        *pServiceHandle = new MonitorServiceData(data);

        return kSTAFOk;
    }
    catch (STAFException &e)
    { 
        *pErrorBuffer = getExceptionString(e,
                "STAFMonitorSerice.cpp: STAFServiceConstruct").adoptImpl();
    }
    catch (...)
    {
        STAFString error(
                    "STAFMonitorService.cpp: STAFServiceConstruct: Caught "
                    "unknown exception in STAFServiceAcceptRequest()");
        *pErrorBuffer = error.adoptImpl();
    }    

    return kSTAFUnknownError;
}


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

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

        MonitorServiceData *pData =
            reinterpret_cast<MonitorServiceData *>(serviceHandle);
        
        STAFServiceInitLevel30 *pInfo =
            reinterpret_cast<STAFServiceInitLevel30 *>(pInitInfo);        

        retCode = STAFHandle::create(pData->fName, pData->fHandlePtr);
        
        if (retCode != kSTAFOk)
            return retCode;

        pData->fMapSem = STAFMutexSemPtr(new STAFMutexSem,
                                         STAFMutexSemPtr::INIT);    
        
        //LOG options
        pData->fLogParser = STAFCommandParserPtr(new STAFCommandParser,
                                                 STAFCommandParserPtr::INIT);
        pData->fLogParser->addOption("LOG",              1,
                                     STAFCommandParser::kValueNotAllowed);
        pData->fLogParser->addOption("MESSAGE",          1,
                                     STAFCommandParser::kValueRequired);
        pData->fLogParser->addOption("NAME",             1,
                                     STAFCommandParser::kValueRequired);
        pData->fLogParser->addOption("RESOLVEMESSAGE",   1,
                                     STAFCommandParser::kValueNotAllowed);
        pData->fLogParser->addOption("NORESOLVEMESSAGE", 1,
                                     STAFCommandParser::kValueNotAllowed);
        pData->fLogParser->addOptionNeed("LOG", "MESSAGE");
        pData->fLogParser->addOptionGroup("RESOLVEMESSAGE NORESOLVEMESSAGE",
                                          0, 1);

        //QUERY options
        pData->fQueryParser = STAFCommandParserPtr(new STAFCommandParser,
                                                   STAFCommandParserPtr::INIT);
        pData->fQueryParser->addOption("QUERY",   1,
                                       STAFCommandParser::kValueNotAllowed);
        pData->fQueryParser->addOption("MACHINE", 1,
                                       STAFCommandParser::kValueRequired);
        pData->fQueryParser->addOption("HANDLE",  1,
                                       STAFCommandParser::kValueRequired);                
        pData->fQueryParser->addOption("NAME",    1,
                                       STAFCommandParser::kValueRequired);
        pData->fQueryParser->addOptionGroup("MACHINE HANDLE NAME", 2, 2);
        pData->fQueryParser->addOptionGroup("HANDLE NAME", 0, 1);

        //LIST options
        pData->fListParser = STAFCommandParserPtr(new STAFCommandParser,
                                                  STAFCommandParserPtr::INIT);
        pData->fListParser->addOption("LIST",     1,
                                      STAFCommandParser::kValueNotAllowed);
        pData->fListParser->addOption("MACHINES", 1,
                                      STAFCommandParser::kValueNotAllowed);
        pData->fListParser->addOption("MACHINE",  1,
                                      STAFCommandParser::kValueRequired);
        pData->fListParser->addOption("NAMES",    1,
                                      STAFCommandParser::kValueNotAllowed);
        pData->fListParser->addOption("SETTINGS", 1,
                                      STAFCommandParser::kValueNotAllowed);
        pData->fListParser->addOptionGroup("MACHINES MACHINE SETTINGS", 1, 1);
        pData->fListParser->addOptionGroup("MACHINES NAME", 0, 1);
        pData->fListParser->addOptionGroup("SETTINGS NAME", 0, 1);


        //DELETE options
        pData->fDeleteParser = STAFCommandParserPtr(new STAFCommandParser,
                                                    STAFCommandParserPtr::INIT);
        pData->fDeleteParser->addOption("DELETE",  1,
                                        STAFCommandParser::kValueNotAllowed);
        pData->fDeleteParser->addOption("CONFIRM", 1,
                                        STAFCommandParser::kValueNotAllowed);
        pData->fDeleteParser->addOption("BEFORE",  1,
                                        STAFCommandParser::kValueRequired);

        pData->fDeleteParser->addOptionNeed("DELETE", "CONFIRM");

        //SET options
        pData->fSetParser = STAFCommandParserPtr(new STAFCommandParser,
                            STAFCommandParserPtr::INIT);
        pData->fSetParser->addOption("SET",                 1,
                                     STAFCommandParser::kValueNotAllowed);
        pData->fSetParser->addOption("NORESOLVEMESSAGE",    1,
                                     STAFCommandParser::kValueNotAllowed);
        pData->fSetParser->addOption("RESOLVEMESSAGE",      1,
                                     STAFCommandParser::kValueNotAllowed);
        pData->fSetParser->addOptionGroup("NORESOLVEMESSAGE RESOLVEMESSAGE",
                                          0, 1);