stafreg.cpp

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

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

#include "STAFOSTypes.h"
#include "STAF.h"
#include "STAFUtil.h"
#include "STAF_iostream.h"
#include "STAF_fstream.h"
#include "STAFFileSystem.h"

const unsigned int MAX_ATTEMPTS = 3;

int main(void)
{
    // Register with STAF

    STAFHandlePtr handle;
    
    unsigned int rc = STAFHandle::create("STAFRegistrationProgram", handle);

    if (rc)
    {
        cout << "STAFReg: Error registering with STAF, RC: " << rc << endl;
        return 1;
    }

    // Get STAFRoot

    STAFResultPtr rootResult = handle->submit("local", "var",
                                              "resolve string {STAF/Config/STAFRoot}");

    if (rootResult->rc)
    {
        cout << "STAFReg: Error resolving {STAF/Config/STAFRoot}, RC: "
             << rootResult->rc << endl;
        return 1;
    }

    // Get OS name

    STAFResultPtr osNameResult =
        handle->submit("local", "var", "resolve string {STAF/Config/OS/Name}");

    if (osNameResult->rc)
    {
        cout << "STAFReg: Error resolving {STAF/Config/OS/Name}, RC: "
             << osNameResult->rc << endl;
        return 1;
    }

    // Get OS major version

    STAFResultPtr osMajorResult =
        handle->submit("local", "var", "resolve string {STAF/Config/OS/MajorVersion}");

    if (osMajorResult->rc)
    {
        cout << "STAFReg: Error resolving {STAF/Config/OS/MajorVersion}, RC: "
             << osMajorResult->rc << endl;
        return 1;
    }

    // Get OS minor version

    STAFResultPtr osMinorResult =
        handle->submit("local", "var", "resolve string {STAF/Config/OS/MinorVersion}");

    if (osMinorResult->rc)
    {
        cout << "STAFReg: Error resolving {STAF/Config/OS/MinorVersion}, RC: "
             << osMinorResult->rc << endl;
        return 1;
    }

    // Get OS revision

    STAFResultPtr osRevResult =
        handle->submit("local", "var", "resolve string {STAF/Config/OS/Revision}");

    if (osRevResult->rc)
    {
        cout << "STAFReg: Error resolving {STAF/Config/OS/Revision}, RC: "
             << osRevResult->rc << endl;
        return 1;
    }

    // Get STAF Version

    STAFResultPtr versionResult = handle->submit("local", "misc", "version");

    if (versionResult->rc)
    {
        cout << "STAFReg: Error getting STAF version, RC: " 
             << versionResult->rc << endl;
        return 1;
    }

    // Get file separator

    STAFResultPtr fileSepResult =
        handle->submit("local", "var", "resolve string {STAF/Config/Sep/File}");

    if (fileSepResult->rc)
    {
        cout << "STAFReg: Error resolving {STAF/Config/Sep/File}, RC: "
             << fileSepResult->rc << endl;
        return 1;
    }

    // Get data directory

    STAFResultPtr dataDirResult =
        handle->submit("local", "var", "resolve string {STAF/DataDir}");

    if (dataDirResult->rc)
    {
        cout << "STAFReg: Error resolving {STAF/DataDir}, RC: "
             << dataDirResult->rc << endl;
        return 1;
    }

    // Open registration information file

    STAFString inputFileName = rootResult->result + fileSepResult->result +
                               "STAFReg.inf";
    fstream input(inputFileName.toCurrentCodePage()->buffer(), ios::in);

    if (!input)
    {
        cout << "STAFReg: Error opening "
             << inputFileName.toCurrentCodePage()->buffer() << endl;
        return 1;
    }

    // Read in registration information

    char buffer[1024] = { 0 };
    STAFString data("version: ");

    data += versionResult->result + kUTF8_SCOLON;
    data += "osname: " + osNameResult->result + kUTF8_SCOLON;
    data += "osmajor: " + osMajorResult->result + kUTF8_SCOLON;
    data += "osminor: " + osMinorResult->result + kUTF8_SCOLON;
    data += "osrev: " + osRevResult->result + kUTF8_SCOLON;

    do
    {
        input.getline(buffer, sizeof(buffer));

        if (input.eof()) continue;

        data += buffer;
        data += kUTF8_SCOLON;
    } while (!(!input) && !input.eof());


    // Submit registration data to automate.  Note, we try up to MAX_ATTEMPTS
    // times, as some OSes (e.g., AIX) where the first attempt gets a
    // NoPathToMachine error (for unknown reasons).

    bool registered = false;

    STAFString request("register type STAF data ");
    request += STAFHandle::wrapData(data);

    STAFResultPtr result = handle->submit(
        "automate.austin.ibm.com", "register", request);

    for (unsigned int attemptCount = 1;
         (attemptCount < MAX_ATTEMPTS) && (result->rc == kSTAFNoPathToMachine);
         ++attemptCount)
    {
        result = handle->submit(
            "automate.austin.ibm.com", "register", request);
    }

    if (result->rc == 0) registered = true;

    // Store STAFReg.cmp in directory {STAF/DataDir}/register

    STAFFSPath registerPath;
    registerPath.setRoot(dataDirResult->result);
    registerPath.addDir("register");
    STAFString registerDataDir = registerPath.asString();

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

    if (!registerPath.exists())
    {
        try
        {
            registerPath.createDirectory(kSTAFFSCreatePath);
        }
        catch (...)
        { 
            cout << "STAFReg: Error creating registration data directory: "
                 << registerDataDir.toCurrentCodePage()->buffer() << endl;
            return 1;
        }
    }

    // Write the registration data to the STAFReg.cmp file or if
    // registration failed, write an error message to STAFReg.cmp

    STAFString outputFileName = registerDataDir +
        fileSepResult->result + "STAFReg.cmp";

    if (registered)
    {
        fstream output(outputFileName.toCurrentCodePage()->buffer(),
                       ios::out);
        output << "Thanks for registering!" << endl
               << "The following data was sent to automate.austin.ibm.com:"
               << endl << endl << data << endl;
        cout << endl << "Successfully registered STAF, Thank you!";
    }
    else
    {
        fstream output(outputFileName.toCurrentCodePage()->buffer(),
                       ios::out);
        output << "Registration failed" << endl;
    }

    return 0;
}