stafconfig.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_iostream.h"
#include "STAF_fstream.h"
#include "STAFString.h"
#include "STAFProc.h"
#include "STAFProcUtil.h"
#include "STAFConfig.h"
#include "STAFUtil.h"
#include "STAFConnectionManager.h"
#include "STAFCommandParser.h"
#include "STAFException.h"
#include "STAFDelegatedService.h"
#include "STAFExternalService.h"
#include "STAFNotificationList.h"
#include "STAFTrustManager.h"
#include "STAFDiagManager.h"
#include "STAFServiceManager.h"
#include "STAFThreadManager.h"
#include "STAFProcessService.h"
#include "STAFTrace.h"
#include "STAFTraceService.h"

unsigned int handleMachineNicknameConfig(STAFString line);
unsigned int handleInterfaceConfig(STAFString line);
unsigned int handleTrustConfig(STAFString line);
unsigned int handleNotifyConfig(STAFString line);
unsigned int handleTraceConfig(STAFString line);
unsigned int handleServiceConfig(STAFString line);
unsigned int handleServiceLoaderConfig(STAFString line);
unsigned int handleAuthenticatorConfig(STAFString line);
unsigned int handleSetConfig(STAFString line);

unsigned int fSLSNum = 1;
const STAFVariablePool *varPoolList[] = { 0, 0 };
unsigned int varPoolListSize = 2;
const unsigned int maxLineLength = 2048;

unsigned int readConfigFile(const STAFString &filename)
{
    // Init the variable pool list
    varPoolList[0] = *gSharedVariablePoolPtr;
    varPoolList[1] = *gGlobalVariablePoolPtr;

    unsigned int rc = 0;

    ifstream config(filename.toCurrentCodePage()->buffer());

    if (!config)
    {
        cout << "Could not find config file " << filename << endl;
        return 1;
    }

    STAFString whiteSpace("\x20\x09\x0A\x0D");
    STAFString line;
    char configLine[maxLineLength];

    for(; config.good() && !rc;)
    {
        configLine[0] = 0;
        config.getline(configLine, maxLineLength);

        if (!config.good())
        {
            if (!config.eof())
            {
                cout << "Line in configuration file exceeds maximum length of "
                     << STAFString(maxLineLength) << " characters" << endl;
                rc = 1;
                break;
            }

            if (configLine == "") break;
        }

        STAFString thisLine(configLine);

        if ((thisLine == "") ||
            (thisLine.findFirstNotOf(whiteSpace) == STAFString::kNPos) ||
            (thisLine.subString(0, 1) == kUTF8_POUND))
        {
            if (line.length() != 0)
            {
                cout << "Invalid continuation line, " << thisLine << endl;
                rc = 1;
            }

            continue;
        }
        else if (thisLine.subString(thisLine.length() - 1, 1) == kUTF8_BSLASH)
        {
            line += thisLine.subString(0,
                    thisLine.length() - 1).strip(STAFString::kFront);
            continue;
        }
        else
        {
            line += thisLine.strip(STAFString::kFront);
        }

        STAFString firstLowerWord = line.subWord(0, 1).lowerCase();

        if (firstLowerWord == "machinenickname")
            rc = handleMachineNicknameConfig(line);
        else if (firstLowerWord == "interface")
            rc = handleInterfaceConfig(line);
        else if (firstLowerWord == "trust")
            rc = handleTrustConfig(line);
        else if (firstLowerWord == "notify")
            rc = handleNotifyConfig(line);
        else if (firstLowerWord == "trace")
            rc = handleTraceConfig(line);
        else if (firstLowerWord == "service")
            rc = handleServiceConfig(line);
        else if (firstLowerWord == "serviceloader")
            rc = handleServiceLoaderConfig(line);
        else if (firstLowerWord == "authenticator")
            rc = handleAuthenticatorConfig(line);
        else if (firstLowerWord == "set")
            rc = handleSetConfig(line);
        else
        {
            cout << "Unknown config command, " << line << endl;
            rc = 1;
        }

        // Reset line for the next statement
        line = STAFString();
    }

    return rc;
}

unsigned int handleTrustConfig(STAFString line)
{
    STAFCommandParser fTrustParser;

    // trust config options

    fTrustParser.addOption("TRUST",   1,
        STAFCommandParser::kValueNotAllowed);
    fTrustParser.addOption("LEVEL",   1,
        STAFCommandParser::kValueRequired);
    fTrustParser.addOption("MACHINE", 0,
        STAFCommandParser::kValueRequired);
    fTrustParser.addOption("USER", 0,
        STAFCommandParser::kValueRequired);
    fTrustParser.addOption("DEFAULT", 1,
        STAFCommandParser::kValueNotAllowed);

    // trust config groups

    fTrustParser.addOptionGroup("LEVEL",                1, 1);
    fTrustParser.addOptionGroup("MACHINE USER DEFAULT", 1, 1);

    STAFCommandParseResultPtr parsedResult = fTrustParser.parse(line);

    if (parsedResult->rc != kSTAFOk)
    {
        cout << "Error on TRUST definition, " << line << endl
             << parsedResult->errorBuffer << endl;

        return 1;
    }

    STAFString errorBuffer;
    STAFString levelString;
    STAFRC_t rc = RESOLVE_STRING_OPTION("LEVEL", levelString);

    if (rc != kSTAFOk)
    {
        cout << "Error on TRUST definition, " << line << endl
             << "Error resolving " << parsedResult->optionValue("LEVEL")
             << ", RC: " << rc  << endl;
        return 1;
    }

    if (!levelString.isDigits())
    {
        cout << "Error on TRUST definition, " << line << endl
             << "The <Level> must be a non-negative integer" << endl;
        return 1;
    }

    unsigned int level = levelString.asUInt();

    if (parsedResult->optionTimes("DEFAULT") != 0)
    {
        rc = gTrustManagerPtr->setDefaultTrusteeLevel(level);

        if (rc != kSTAFOk)
        {
            cout << "Error setting DEFAULT TRUST definition, " << line
                 << endl << "Error code: " << rc << endl;
            return 1;
        }
    }
    else if (parsedResult->optionTimes("MACHINE") != 0)
    {
        for(int i = 1; i <= parsedResult->optionTimes("MACHINE"); ++i)
        {
            STAFString machine;
            rc = RESOLVE_INDEXED_STRING_OPTION("MACHINE", i, machine);

            if (rc != kSTAFOk)
            {
                cout << "Error on TRUST definition, " << line << endl
                     << "Error resolving "
                     << parsedResult->optionValue("MACHINE", i) << ", RC: "
                     << rc << endl;
                return 1;
            }

            rc = gTrustManagerPtr->setMachineTrusteeLevel(machine, level);

            if (rc != kSTAFOk)
            {
                cout << "Error adding TRUST definition, " << line
                     << endl << "Error code: " << rc << endl;
                return 1;
            }
        }
    }
    else
    {
        for(int i = 1; i <= parsedResult->optionTimes("USER"); ++i)
        {
            STAFString user;
            RESOLVE_INDEXED_STRING_OPTION("USER", i, user);

            if (rc != kSTAFOk)
            {
                cout << "Error on TRUST definition, " << line << endl
                     << "Error resolving "
                     << parsedResult->optionValue("USER", i) << ", RC: "
                     << rc << endl;
                return 1;
            }

            // XXX: Need to specify whether level is for machine or user
            rc = gTrustManagerPtr->setUserTrusteeLevel(user, level);

            if (rc != kSTAFOk)
            {
                cout << "Error adding TRUST definition, " << line
                     << endl << "Error code: " << rc << endl;
                return 1;
            }
        }
    }

    return 0;
}


unsigned int handleInterfaceConfig(STAFString line)
{
    STAFCommandParser fInterfaceParser;

    // interface config options

    fInterfaceParser.addOption("INTERFACE", 1,
        STAFCommandParser::kValueRequired);
    fInterfaceParser.addOption("LIBRARY",   1,
        STAFCommandParser::kValueRequired);
    fInterfaceParser.addOption("OPTION",    0,
        STAFCommandParser::kValueRequired);

    // interface config groups

    fInterfaceParser.addOptionGroup("INTERFACE", 1, 1);
    fInterfaceParser.addOptionGroup("LIBRARY",   1, 1);

    STAFCommandParseResultPtr parsedResult = fInterfaceParser.parse(line);

    if (parsedResult->rc != kSTAFOk)
    {
        cout << "Error on INTERFACE definition, " << line << endl
             << parsedResult->errorBuffer << endl;
        return 1;
    }

    STAFString errorBuffer;
    STAFString name;
    STAFRC_t rc = RESOLVE_STRING_OPTION("INTERFACE", name);

    if (rc != kSTAFOk)
    {
        cout << "Error on INTERFACE definition, " << line << endl
             << "Error resolving INTERFACE name "
             << parsedResult->optionValue("INTERFACE") << ", RC: " << rc
             << endl;
        return 1;
    }

    if (name.toLowerCase() == "local")
    {
        cout << "Error on INTERFACE definition, " << line << endl
             << "Interface name " << name
             << " is reserved for the local IPC interface" << endl;
        return 1;
    }

    STAFString library;
    RESOLVE_STRING_OPTION("LIBRARY", library);

    if (rc != kSTAFOk)
    {
        cout << "Error on INTERFACE definition, " << line << endl
             << "Error resolving LIBRARY "
             << parsedResult->optionValue("LIBRARY") << ", RC: " << rc << endl;
        return 1;
    }

    STAFConnectionManager::ConnectionProviderOptionList optionList;

    for (int i = 1; i <= parsedResult->optionTimes("OPTION"); ++i)
    {
        STAFString option;
        RESOLVE_INDEXED_STRING_OPTION("OPTION", i, option);

        if (rc != kSTAFOk)
        {
            cout << "Error on INTERFACE definition, " << line << endl
                 << "Error resolving OPTION"
                 << parsedResult->optionValue("OPTION", i)<< ", RC: " << rc
                 << endl;
            return 1;
        }

        optionList.push_back(option);
    }

    rc = gConnectionManagerPtr->addConnectionProvider(name, library, optionList,
                                                      errorBuffer);

    if (rc != kSTAFOk)
    {
        cout << "Error on INTERFACE definition, " << line << endl
             << "Error creating interface, RC: " << rc << ", Reason: "
             << errorBuffer << endl;
        return 1;
    }

    return 0;
}

unsigned int handleMachineNicknameConfig(STAFString line)
{
    STAFCommandParser fMachineNicknameParser;

    // machine config options

    fMachineNicknameParser.addOption("MACHINENICKNAME", 1,
        STAFCommandParser::kValueRequired);

    STAFCommandParseResultPtr parsedResult = fMachineNicknameParser.parse(line);

    if (parsedResult->rc != kSTAFOk)
    {
        cout << "Error on MACHINENICKNAME definition, " << line << endl
             << parsedResult->errorBuffer << endl;
        return 1;
    }
    
    STAFString errorBuffer;
    STAFString machineNickname;
    STAFRC_t rc = RESOLVE_STRING_OPTION("MACHINENICKNAME", machineNickname);

    if (rc != kSTAFOk)
    {
        cout << "Error on MACHINENICKNAME definition, " << line << endl
             << "Error resolving "
             << parsedResult->optionValue("MACHINENICKNAME")
             << ", RC: " << rc << endl;
        return 1;
    }

    *gMachineNicknamePtr = machineNickname;

    return 0;
}


unsigned int handleNotifyConfig(STAFString line)
{
    STAFCommandParser fNotifyParser;

    // notify config options

    fNotifyParser.addOption("NOTIFY",     1,
        STAFCommandParser::kValueNotAllowed);
    fNotifyParser.addOption("ONSTART",    1,
        STAFCommandParser::kValueNotAllowed);
    fNotifyParser.addOption("ONSHUTDOWN", 1,
        STAFCommandParser::kValueNotAllowed);
    fNotifyParser.addOption("NAME",       1,
        STAFCommandParser::kValueRequired);
    fNotifyParser.addOption("HANDLE",     1,
        STAFCommandParser::kValueRequired);
    fNotifyParser.addOption("MACHINE",    1,
        STAFCommandParser::kValueRequired);
    fNotifyParser.addOption("PRIORITY",   1,
        STAFCommandParser::kValueRequired);

    // notify config groups

    fNotifyParser.addOptionGroup("NAME HANDLE",        1, 1);
    fNotifyParser.addOptionGroup("ONSTART ONSHUTDOWN", 1, 1);
    fNotifyParser.addOptionGroup("MACHINE",            1, 1);
    fNotifyParser.addOptionGroup("NOTIFY",             1, 1);

    STAFCommandParseResultPtr parsedResult = fNotifyParser.parse(line);

    if (parsedResult->rc != kSTAFOk)
    {
        cout << "Error on NOTIFY definition, " << line << endl
             << parsedResult->errorBuffer << endl;
        return 1;
    }

    unsigned int onStart = parsedResult->optionTimes("ONSTART");
    unsigned int notifyName = parsedResult->optionTimes("NAME");
    unsigned int priority = 5;
    unsigned int handle = 0;
    STAFString name;
    STAFString machine;
    STAFString errorBuffer;
    STAFRC_t rc = RESOLVE_OPTIONAL_UINT_OPTION("PRIORITY", priority);

    if (!rc) RESOLVE_OPTIONAL_UINT_OPTION("HANDLE", handle);
    if (!rc) RESOLVE_OPTIONAL_STRING_OPTION("NAME", name);
    if (!rc) RESOLVE_STRING_OPTION("MACHINE", machine);

    if (rc != kSTAFOk)
    {
        cout << "Error on NOTIFY definition, " << line << endl
             << "Error with, " << errorBuffer << ", RC: " << rc << endl;
        return 1;
    }

    STAFNotificationList *notificationList = gNotifyOnStartPtr;

    if (!onStart) notificationList = gNotifyOnShutdownPtr;

    if (notifyName) rc = notificationList->reg(machine, name, priority);
    else rc = notificationList->reg(machine, handle, priority);

    return rc;
}


unsigned int handleTraceConfig(STAFString line)
{
    STAFCommandParser fTraceParser;

    //trace options
    fTraceParser.addOption("TRACE", 1,
        STAFCommandParser::kValueNotAllowed);
    fTraceParser.addOption("ENABLE", 1,
        STAFCommandParser::kValueNotAllowed);
    fTraceParser.addOption("DISABLE", 1,
        STAFCommandParser::kValueNotAllowed);
    fTraceParser.addOption("ALL", 1,
        STAFCommandParser::kValueNotAllowed);
    fTraceParser.addOption("TRACEPOINTS", 1,
        STAFCommandParser::kValueAllowed);
    fTraceParser.addOption("TRACEPOINT", 0,
        STAFCommandParser::kValueRequired);
    fTraceParser.addOption("SERVICES", 1,
        STAFCommandParser::kValueAllowed);
    fTraceParser.addOption("SERVICE", 0,
        STAFCommandParser::kValueRequired);
    fTraceParser.addOption("SET", 1,
        STAFCommandParser::kValueNotAllowed);
    fTraceParser.addOption("DESTINATION", 1,
        STAFCommandParser::kValueNotAllowed);