stafconfig.cpp

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

        for (int i = 1; !rc && (i <= parsedResult->optionTimes("OPTION"));
             ++i)
        {
            STAFString option;
            rc = RESOLVE_INDEXED_STRING_OPTION("OPTION", i, option);
            options.push_back(option);
        }

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

        service = STAFServicePtr(new STAFExternalService("STAFServiceLoader" +
                                                         STAFString(fSLSNum),
                                library, exec, options, parms,
                                kSTAFServiceTypeServiceLoader),
                                STAFServicePtr::INIT);

        fSLSNum++;

        rc = gServiceManagerPtr->addSLS(service);

        if (rc)
        {
            cout << "Error, RC: " << rc << ", adding ServiceLoader definition, "
                 << line << endl;
            return 1;
        }
    }
    catch (STAFServiceCreateException &e)
    {
        cout << "Error on ServiceLoader definition, " << line << endl
             << e.getErrorCode() << ":" << e.getText() << endl;
        return 1;
    }
    catch (STAFException &e)
    {
        e.write();
        return 1;
    }
    catch (...)
    {
        // XXX: Why is this here?
        cout << "Exception caught. Need to get this out (STAFConfig.cpp)"
             << endl;
        return 1;
    }

    return 0;
}


unsigned int handleAuthenticatorConfig(STAFString line)
{
    STAFCommandParser fAuthenticatorParser;

    // AUTHENTICATOR <Name>
    // LIBRARY <Library> [EXECUTE <Exec>] {OPTION <OpName[=OpValue]>}
    //     [PARMS <Parms>]

    // Authenticator config options

    fAuthenticatorParser.addOption("AUTHENTICATOR",  1,
        STAFCommandParser::kValueRequired);
    fAuthenticatorParser.addOption("LIBRARY",    1,
        STAFCommandParser::kValueRequired);
    fAuthenticatorParser.addOption("EXECUTE",    1,
        STAFCommandParser::kValueRequired);
    fAuthenticatorParser.addOption("OPTION",    0,
        STAFCommandParser::kValueRequired);
    fAuthenticatorParser.addOption("PARMS",    1,
        STAFCommandParser::kValueRequired);

    // service config groups

    fAuthenticatorParser.addOptionGroup("AUTHENTICATOR", 1, 1);
    fAuthenticatorParser.addOptionGroup("LIBRARY", 1, 1);

    // service config needs

    fAuthenticatorParser.addOptionNeed("EXECUTE OPTION PARMS", "LIBRARY");

    STAFCommandParseResultPtr parsedResult = fAuthenticatorParser.parse(line);

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

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

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

    rc = gServiceManagerPtr->verifyServiceName(name);

    if (rc != kSTAFOk)
    {
        cout << "Error on Service definition, " << line << endl
             << "Service name " << name << " is not valid, RC: " << rc << endl;
        cout << INVALID_SERVICE_NAME_ERROR_MESSAGE() << endl;
        return 1;
    }

    try
    {
        STAFServicePtr service;

        // Setup external service data
        STAFString library;
        STAFString exec;
        STAFString parms;
        STAFExternalService::OptionList options;

        rc = RESOLVE_STRING_OPTION("LIBRARY", library);

        if (!rc) rc = RESOLVE_STRING_OPTION("EXECUTE", exec);
        if (!rc) rc = RESOLVE_STRING_OPTION("PARMS", parms);

        for (int i = 1; !rc && (i <= parsedResult->optionTimes("OPTION"));
             ++i)
        {
            STAFString option;
            rc = RESOLVE_INDEXED_STRING_OPTION("OPTION", i, option);
            options.push_back(option);
        }


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

        service = STAFServicePtr(new STAFExternalService(name, library,
                                 exec, options, parms,
                                 kSTAFServiceTypeAuthenticator),
                                 STAFServicePtr::INIT);

        rc = gServiceManagerPtr->addAuthenticator(service);

        if (rc)
        {
            cout << "Error, RC: " << rc
                << ", adding Authenticator definition, "
                << line << endl;
            return 1;
        }

        // Assign as default authenticator if it has not been specified yet.
        if ((gServiceManagerPtr->getDefaultAuthenticator() == gNoneString) ||
            (gServiceManagerPtr->getDefaultAuthenticator() == ""))
        {
            gServiceManagerPtr->setDefaultAuthenticator(name);
        }
    }
    catch (STAFServiceCreateException &e)
    {
        cout << "Error on Authenticator definition, " << line << endl
             << e.getErrorCode() << ":" << e.getText() << endl;
        return 1;
    }
    catch (STAFException &e)
    {
        e.write();
        return 1;
    }
    catch (...)
    {
        // XXX: Why is this here?
        cout << "Exception caught. Need to get this out (STAFConfig.cpp)"
             << endl;
        return 1;
    }

    return 0;
}


unsigned int handleSetConfig(STAFString line)
{
    STAFCommandParser fSetParser;

    // set config options

    // XXX: Note ALLOWMULTIREG is deprecated.  It is currently allowed by the
    //      parser, but ignored everywhere else, for backward compatibility.
    //      It will be removed entirely in STAF V3.0

    fSetParser.addOption("SET",                   1,
        STAFCommandParser::kValueNotAllowed);
    fSetParser.addOption("SYSTEM",                1,
        STAFCommandParser::kValueNotAllowed);
    fSetParser.addOption("SHARED",                1,
        STAFCommandParser::kValueNotAllowed);
    fSetParser.addOption("VAR",                   0,
        STAFCommandParser::kValueRequired);
    fSetParser.addOption("DATADIR",               1,
        STAFCommandParser::kValueRequired);
    fSetParser.addOption("CONNECTATTEMPTS",       1,
        STAFCommandParser::kValueRequired);
    fSetParser.addOption("CONNECTRETRYDELAY",     1,
        STAFCommandParser::kValueRequired);
    fSetParser.addOption("INTERFACECYCLING",      1,
        STAFCommandParser::kValueRequired);
    fSetParser.addOption("MAXFILES",              1,
        STAFCommandParser::kValueRequired);
    fSetParser.addOption("MAXQUEUESIZE",          1,
        STAFCommandParser::kValueRequired);
    fSetParser.addOption("INITIALTHREADS",        1,
        STAFCommandParser::kValueRequired);
    fSetParser.addOption("THREADGROWTHDELTA",     1,
        STAFCommandParser::kValueRequired);
    fSetParser.addOption("ALLOWMULTIREG",         1,
        STAFCommandParser::kValueNotAllowed);
    fSetParser.addOption("DEFAULTINTERFACE",      1,
        STAFCommandParser::kValueRequired);
    fSetParser.addOption("DEFAULTAUTHENTICATOR",  1,
        STAFCommandParser::kValueRequired);
    fSetParser.addOption("DEFAULTSTOPUSING",      1,
        STAFCommandParser::kValueRequired);
    fSetParser.addOption("DEFAULTNEWCONSOLE",     1,
        STAFCommandParser::kValueNotAllowed);
    fSetParser.addOption("DEFAULTSAMECONSOLE",    1,
        STAFCommandParser::kValueNotAllowed);
    fSetParser.addOption("DEFAULTFOCUS",          1,
        STAFCommandParser::kValueRequired);
    fSetParser.addOption("DEFAULTAUTHDISABLEDACTION", 1,
        STAFCommandParser::kValueRequired);
    fSetParser.addOption("DEFAULTAUTHUSERNAME",   1,
        STAFCommandParser::kValueRequired);
    fSetParser.addOption("DEFAULTAUTHPASSWORD",   1,
        STAFCommandParser::kValueRequired);
    fSetParser.addOption("PROCESSAUTHMODE",       1,
        STAFCommandParser::kValueRequired);
    fSetParser.addOption("DEFAULTSHELL",          1,
        STAFCommandParser::kValueRequired);
    fSetParser.addOption("DEFAULTNEWCONSOLESHELL", 1,
        STAFCommandParser::kValueRequired);
    fSetParser.addOption("DEFAULTSAMECONSOLESHELL", 1,
        STAFCommandParser::kValueRequired);
    fSetParser.addOption("ENABLEDIAGS", 1,
        STAFCommandParser::kValueNotAllowed);
    fSetParser.addOption("STRICTFSCOPYTRUST", 1,
        STAFCommandParser::kValueNotAllowed);
    fSetParser.addOption("RESULTCOMPATIBILITYMODE", 1,
        STAFCommandParser::kValueRequired);

    // set config groups

    fSetParser.addOptionGroup("SET", 1 , 1);
    fSetParser.addOptionGroup("DEFAULTNEWCONSOLE DEFAULTSAMECONSOLE", 0 , 1);
    fSetParser.addOptionGroup("SYSTEM SHARED", 0, 1);
    fSetParser.addOptionNeed("SHARED SYSTEM", "VAR");

    STAFCommandParseResultPtr parsedResult = fSetParser.parse(line);

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

    STAFString errorBuffer;

    if (parsedResult->optionTimes("VAR") != 0)
    {
        // handle var config

        STAFVariablePoolPtr thePool;

        if (parsedResult->optionTimes("SHARED") != 0)
        {
            thePool = *gSharedVariablePoolPtr;
        }
        else
        {
            thePool = *gGlobalVariablePoolPtr;
        }

        for(int i = 1; i <= parsedResult->optionTimes("VAR"); ++i)
        {
            STAFString nameAndValue = parsedResult->optionValue("VAR", i);
            unsigned int equalPos = nameAndValue.find(kUTF8_EQUAL);

            if (equalPos == STAFString::kNPos)
            {
                cout << "Error on variable definition, " << line << endl
                     << errorBuffer << endl;
                return 1;
            }

            thePool->set(nameAndValue.subString(0, equalPos),
                         nameAndValue.subString(equalPos +
                         nameAndValue.sizeOfChar(equalPos)));
        }

        return 0;
    }

    STAFRC_t rc = kSTAFOk;

    if (parsedResult->optionTimes("DATADIR") != 0)
    {
        // Resolve the value for the DATADIR operational setting

        STAFString dataDir;

        rc = RESOLVE_STRING_OPTION("DATADIR", dataDir);

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

        // Create the data directory if it doesn't exist

        STAFFSPath dataPath;
        dataPath.setRoot(dataDir);

        if (!dataPath.exists())
        {
            try
            {
                dataPath.createDirectory(kSTAFFSCreatePath);
            }
            catch (...)
            { /* Do Nothing */ }

            if (!dataPath.exists())
            {
                cout << "Error creating DATADIR directory: "
                     << dataDir << endl;
                return 1;
            }
        }

        *gSTAFWriteLocationPtr = dataDir;

        // Set STAF system variable STAF/DataDir to the datadir value
        // This is a "read-only" STAF variable.

        (*gGlobalVariablePoolPtr)->set("STAF/DataDir", dataDir);

        STAFProcessService::setTempDirectory(dataDir + *gFileSeparatorPtr + "tmp");
    }

    if (parsedResult->optionTimes("CONNECTATTEMPTS") != 0)
    {
        // Handle CONNECTATTEMPTS

        STAFString unresConnectAttempts =
            parsedResult->optionValue("CONNECTATTEMPTS");

        STAFString connectAttempts;

        rc = RESOLVE_STRING_OPTION("CONNECTATTEMPTS", connectAttempts);

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

        if (!connectAttempts.isDigits())
        {
            cout << "Error on CONNECTATTEMPTS setting, " << line << endl
                 << "CONNECTATTEMPTS must be a positive integer" << endl;
            return 1;
        }

        gConnectionAttempts = connectAttempts.asUInt();

        if (gConnectionAttempts < 1)
        {
            cout << "Error on CONNECTATTEMPTS setting, " << line << endl
                 << "CONNECTATTEMPTS must be a positive integer" << endl;
            return 1;
        }
    }

    if (parsedResult->optionTimes("CONNECTRETRYDELAY") != 0)
    {
        // Handle CONNECTRETRYDELAY

        STAFString unresConnectRetryDelay =
            parsedResult->optionValue("CONNECTRETRYDELAY");

        STAFString connectRetryDelay;

        rc = RESOLVE_STRING_OPTION("CONNECTRETRYDELAY", connectRetryDelay);

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

        if (!connectRetryDelay.isDigits())
        {
            cout << "Error on CONNECTRETRYDELAY setting, " << line << endl
                 << "CONNECTRETRYDELAY must be a non-negative integer" << endl;
            return 1;
        }

        gConnectionRetryDelay = connectRetryDelay.asUInt();
    }
    
    if (parsedResult->optionTimes("INTERFACECYCLING") != 0)
    {
        // Handle INTERFACECYCLING

        STAFString unresInterfaceCycling = parsedResult->optionValue(
            "INTERFACECYCLING");

        STAFString interfaceCycling;

        rc = RESOLVE_STRING_OPTION("INTERFACECYCLING", interfaceCycling);

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

        if (interfaceCycling.toUpperCase() == "ENABLED")
        {
            gConnectionManagerPtr->enableAutoInterfaceCycling();
        }
        else if (interfaceCycling.toUpperCase() == "DISABLED")
        {
            gConnectionManagerPtr->disableAutoInterfaceCycling();
        }
        else
        {
            cout << "Error on INTERFACECYCLING setting, " << line << endl
                 << "INTERFACECYCLING must be set to Enabled or Disabled"
                 << endl;
            return 1;
        }
    }
    
    if (parsedResult->optionTimes("MAXFILES") != 0)
    {
        // Handle MAXFILES

        STAFString maxFiles;

        rc = RESOLVE_STRING_OPTION("MAXFILES", maxFiles);

        if (rc != kSTAFOk)
        {
            cout << "Error on MAXFILES setting, " << line << endl
                 << "Error resolving " << parsedResult->optionValue("MAXFILES")
                 << ", RC: " << rc << endl;